Built with Alectryon, running Coq+SerAPI v8.13.0+0.13.0. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑ Ctrl+↓ to navigate, Ctrl+🖱️ to focus. On Mac, use instead of Ctrl.
(******************************************************************************)
(*                                                                            *)
(*                     Generalised Hanoi Problem                              *)
(*                                                                            *)
(******************************************************************************)
(*                                                                            *)
(*      We consider a generalisation of Hanoi problem :                       *)
(*        a parameter n : the number of pegs                                  *)
(*        a parameter r : r p1 p2 tells that a disk can go from p1 -> p2      *)
(*                                                                            *)
(*    peg n             == type for pegs  (there are n pegs)                  *)
(*    disk k            == type for disks (there are k disk)                  *)
(*    configuration k n == type for hanoi configuration with                  *)
(*                         k disks and n pegs                                 *)
(*    ldisk             == the largest disk                                   *)
(*    sdisk             == the smallest disk                                  *)
(*    d1 \larger d2     == disk d1 is larger than disk d2                     *)
(*    c d               == the peg on which the disk d in the configuration c *)
(*    `c[p]             == a configuration with n disk where all the disks    *)
(*    `p[p1, p2]        == pick a peg (if possible) that is diffenent from p1 *)
(*                         and p2                                             *)
(*                         are on peg p                                       *)
(*    on_top d c        == the disk c is on top of its peg on the             *)
(*                         configuration c                                    *)
(*    rrel              == a regular relation between pegs, rrel p1 p2 is     *)
(*                         true iff peg p1 is different from peg p2           *)
(*    lrel              == a linear relation between pegs, lrel p1 p2 is      *)
(*                         true iff peg p1 is next to peg p2                  *)
(*    srel              == a star relation between pegs, srel p1 p2 is        *)
(*                         true iff p1 != p2 and p1 or p2 is the 0 peg        *)
(*    move r c1 c2      == checks if going from configuration c1              *)
(*                         to configuration c2 is a move compatible with      *)
(*                         relation r (a relation over pegs)                  *)
(*   cdisjoint c1 c2    == configurations c1 and c2 are on different pegs     *) 
(*   cmerge c1 c2       == merge a configuration c1 with m disk and a         *)
(*                         a configuration with n disks to get a configuration*) 
(*                         with m + n disk                                    *)
(*   crshift c          == right shift a configuration c with m + n disks, to *)
(*                         get a configuration with n disks taking the disks  *)
(*                         larger than m                                      *)
(*   clshift c          == right shift a configuration c with m + n disks, to *)
(*                         get a configuration with n disks taking the disks  *)
(*                         smaller than m                                     *)
(*   ↑[c]_ p            == lift a configuration by adding a largest disk on   *)
(*                         peg p. This lifting is done from the largest one   *)
(*                         so to accomodate the usual induction               *)
(*   ↓[c]               == unlift a configuration by removing the largest     *)
(*                         disk                                               *)
(*   plift i p          == lift a configuration by adding a new empty peg i   *)
(*                                                                            *)
(******************************************************************************)

Notation "[ rel _ _ | _ ]" was already used in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope fun_scope. [notation-overridden,parsing]
Notation "_ + _" was already used in scope nat_scope. [notation-overridden,parsing]
Notation "_ - _" was already used in scope nat_scope. [notation-overridden,parsing]
Notation "_ <= _" was already used in scope nat_scope. [notation-overridden,parsing]
Notation "_ < _" was already used in scope nat_scope. [notation-overridden,parsing]
Notation "_ >= _" was already used in scope nat_scope. [notation-overridden,parsing]
Notation "_ > _" was already used in scope nat_scope. [notation-overridden,parsing]
Notation "_ <= _ <= _" was already used in scope nat_scope. [notation-overridden,parsing]
Notation "_ < _ <= _" was already used in scope nat_scope. [notation-overridden,parsing]
Notation "_ <= _ < _" was already used in scope nat_scope. [notation-overridden,parsing]
Notation "_ < _ < _" was already used in scope nat_scope. [notation-overridden,parsing]
Notation "_ * _" was already used in scope nat_scope. [notation-overridden,parsing]
From hanoi Require Import extra gdist. Set Implicit Arguments. Unset Strict Implicit. Unset Printing Implicit Defensive. Section GHanoi. Variable q : nat. (******************************************************************************) (* The pegs are the elements of 'I_q *) (******************************************************************************) Definition peg := 'I_q. Variable r : rel peg. Hypothesis irH : irreflexive r. Hypothesis symH : symmetric r. Section Disk. (******************************************************************************) (* The disks are represented with the element of 'I_n with *) (* the idea that disk d1 is larger than disk d2 is d2 <= d1. *) (******************************************************************************) Variable n : nat. Definition disk := 'I_n. Definition mk_disk m (H : m < n) : disk := Ordinal H. (******************************************************************************) (* Given a configuration c, the disks on the peg p can be reconstructed by *) (* the list in decreasing order of the disk d such that c d = p *) (******************************************************************************) Definition configuration := {ffun disk -> peg}. (* A perfect configuration is one where all the pegs are on a single peg p *) Definition perfect p : configuration := [ffun d => p]. End Disk. Arguments perfect [n]. Local Notation "`c[ p ] " := (perfect p) (format "`c[ p ]", at level 5). (* The smallest disk *) Definition sdisk {n} : disk n.+1 := ord0.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
d:disk 1

d = sdisk
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
d:disk 1

d = sdisk
by apply/val_eqP; case: d => [] []. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
c1, c2:configuration 1

(c1 == c2) = (c1 sdisk == c2 sdisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
c1, c2:configuration 1

(c1 == c2) = (c1 sdisk == c2 sdisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
c1, c2:configuration 1

c1 sdisk = c2 sdisk -> c1 = c2
by move=> H; apply/ffunP=> i; rewrite [i]disk1_all. Qed. (* The largest disk *) Definition ldisk {n} : disk n.+1 := ord_max. (******************************************************************************) (* The disk d is on top of peg (c d) *) (******************************************************************************) Definition on_top n (d : disk n) (c : configuration n) := [forall d1 : disk n, (c d == c d1) ==> (d <= d1)].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c:configuration n

reflect (forall d1 : ordinal_finType n, c d = c d1 -> d <= d1) (on_top d c)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c:configuration n

reflect (forall d1 : ordinal_finType n, c d = c d1 -> d <= d1) (on_top d c)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c:configuration n
H:forall x : ordinal_finType n, (c d == c x) ==> (d <= x)
d1:ordinal_finType n
cdEcd1:c d = c d1

d <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c:configuration n
H:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:ordinal_finType n
(c d == c d1) ==> (d <= d1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c:configuration n
H:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:ordinal_finType n

(c d == c d1) ==> (d <= d1)
by apply/implyP=> /eqP /H. Qed. (******************************************************************************) (* A move is a relation between two configurations c1 c2: *) (* there must exist a disk d1, that is the only one that has changed of *) (* peg (c1 d1 != c2 d1) that is on top of c1 and c2 *) (******************************************************************************) Definition move {n} : rel (configuration n) := [rel c1 c2 | [exists d1 : disk n, [&& r ((c1 : configuration n) d1) (c2 d1), [forall d2, (d1 != d2) ==> (c1 d2 == c2 d2)], on_top d1 c1 & on_top d1 c2]]].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n

reflect (exists d1 : ordinal_finType n, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType n, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]) (move c1 c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n

reflect (exists d1 : ordinal_finType n, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType n, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]) (move c1 c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
d:ordinal_finType n
H1:r (c1 d) (c2 d)
H2:forall x : ordinal_finType n, (d != x) ==> (c1 x == c2 x)
H3:on_top d c1
H4:on_top d c2

[/\ r (c1 d) (c2 d), forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2, on_top d c1 & on_top d c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
d:ordinal_finType n
H1:r (c1 d) (c2 d)
H2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
H3:on_top d c1
H4:on_top d c2
[&& r (c1 d) (c2 d), [forall d2, (d != d2) ==> (c1 d2 == c2 d2)], on_top d c1 & on_top d c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
d:ordinal_finType n
H1:r (c1 d) (c2 d)
H2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
H3:on_top d c1
H4:on_top d c2

[&& r (c1 d) (c2 d), [forall d2, (d != d2) ==> (c1 d2 == c2 d2)], on_top d c1 & on_top d c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n
d:ordinal_finType n
H1:r (c1 d) (c2 d)
H2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
H3:on_top d c1
H4:on_top d c2
d1:ordinal_finType n
H:d != d1

c1 d1 == c2 d1
by rewrite H2. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> on_top d c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> on_top d c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n, d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d

on_top d c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n, d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d

d = d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n, d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d
H:d != d1

false
by case/eqP: H5; apply: H2; rewrite eq_sym. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> on_top d c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> on_top d c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n, d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d

on_top d c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n, d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d

d = d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:ordinal_finType n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n, d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
H5:c1 d != c2 d
H:d != d1

false
by case/eqP: H5; apply: H2; rewrite eq_sym. Qed. (* this holds if r is symmetric *)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n

move c1 c2 = move c2 c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n

move c1 c2 = move c2 c1
by apply/moveP/moveP=> [] [d [H1 H2 H3 H4]]; exists d; split; rewrite 1?symH 1?eq_sym // => e dDe; apply/sym_equal/H2. Qed. (* In a move, the disk that moves accomodates r *)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> r (c1 d) (c2 d)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> r (c1 d) (c2 d)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d:disk n
c1, c2:configuration n
d1:ordinal_finType n
H1:r (c1 d1) (c2 d1)
H2:forall d2 : ordinal_finType n, d1 != d2 -> c1 d2 = c2 d2
H3:on_top d1 c1
H4:on_top d1 c2
c1dDc2d:c1 d <> c2 d

r (c1 d) (c2 d)
by have [/eqP<-|/H2] := boolP (d1 == d). Qed. (* In a move, only one disk moves *)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n

move c1 c2 -> c1 d1 != c2 d1 -> d1 != d2 -> c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n

move c1 c2 -> c1 d1 != c2 d1 -> d1 != d2 -> c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n
d3:ordinal_finType n
H1:r (c1 d3) (c2 d3)
H2:forall d2 : ordinal_finType n, d3 != d2 -> c1 d2 = c2 d2
H3:on_top d3 c1
H4:on_top d3 c2
c1d1Dc2d1:c1 d1 != c2 d1
d1Dd2:d1 != d2

c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n
d3:ordinal_finType n
H1:r (c1 d3) (c2 d3)
H2:forall d2 : ordinal_finType n, d3 != d2 -> c1 d2 = c2 d2
H3:on_top d3 c1
H4:on_top d3 c2
c1d1Dc2d1:c1 d1 != c2 d1
d1Dd2:d1 != d2
d3Dd1:d3 != d1

c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n
d3:ordinal_finType n
H1:r (c1 d3) (c2 d3)
H2:forall d2 : ordinal_finType n, d3 != d2 -> c1 d2 = c2 d2
H3:on_top d3 c1
H4:on_top d3 c2
c1d1Dc2d1:c1 d1 != c2 d1
d1Dd2:d1 != d2
d3Ed1:d3 = d1
c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d1, d2:disk n
c1, c2:configuration n
d3:ordinal_finType n
H1:r (c1 d3) (c2 d3)
H2:forall d2 : ordinal_finType n, d3 != d2 -> c1 d2 = c2 d2
H3:on_top d3 c1
H4:on_top d3 c2
c1d1Dc2d1:c1 d1 != c2 d1
d1Dd2:d1 != d2
d3Ed1:d3 = d1

c1 d2 = c2 d2
by apply: H2; rewrite d3Ed1. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> d1 < d -> c1 d1 != c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> d1 < d -> c1 d1 != c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d

c1 d = c1 d1 -> d <= d1
by have /on_topP := move_on_topl c1Mc2 c1Dc2; apply. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> d1 <= d -> c1 d1 != c2 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> d1 <= d -> c1 d1 != c2 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d

c1 d1 != c2 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d

d != d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
~~ (d <= d1) -> c2 d != c2 d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d

~~ (d <= d1) -> c2 d != c2 d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d

c2 d = c2 d1 -> d <= d1
by have /on_topP := move_on_topr c1Mc2 c1Dc2; apply. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> d1 < d -> c2 d1 != c2 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> d1 < d -> c2 d1 != c2 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d

c2 d = c2 d1 -> d <= d1
by have /on_topP := move_on_topr c1Mc2 c1Dc2; apply. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> d1 <= d -> c2 d1 != c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n

move c1 c2 -> c1 d != c2 d -> d1 <= d -> c2 d1 != c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d

c2 d != c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
c2 d1 != c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d

c2 d1 != c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d

d1 != d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d
~~ (d <= d1) -> c1 d != c1 d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d

~~ (d <= d1) -> c1 d != c1 d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
d, d1:disk n
c1, c2:configuration n
c1Mc2:move c1 c2
c1Dc2:c1 d != c2 d
dLd1:d1 < d

c1 d = c1 d1 -> d <= d1
have /on_topP := move_on_topl c1Mc2 c1Dc2; apply. Qed. (* configuration on different pegs *) Definition cdisjoint m n (c1 : configuration m) (c2 : configuration n) := [forall i, [forall j, c1 i != c2 j]].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n

reflect (forall (i : ordinal_finType m) (j : ordinal_finType n), c1 i != c2 j) (cdisjoint c1 c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n

reflect (forall (i : ordinal_finType m) (j : ordinal_finType n), c1 i != c2 j) (cdisjoint c1 c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
H:forall x : ordinal_finType m, [forall j, c1 x != c2 j]
i:ordinal_finType m
j:ordinal_finType n

c1 i != c2 j
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
H:forall (i : ordinal_finType m) (j : ordinal_finType n), c1 i != c2 j
i:ordinal_finType m
[forall j, c1 i != c2 j]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
H:forall (i : ordinal_finType m) (j : ordinal_finType n), c1 i != c2 j
i:ordinal_finType m

[forall j, c1 i != c2 j]
by apply/forallP=> j; apply: H. Qed. (* merging two configurations : c1 for the small disks, c2 for the big ones *) Definition cmerge m n (c1 : configuration m) (c2 : configuration n) := [ffun i => match tsplit i with inl j => c1 j | inr j => c2 j end]. (* right shifting a configuration : taking the disks smaller than n *) Definition crshift m n (c : configuration (m + n)) : configuration n := [ffun i => c (trshift m i)]. (* left shifting a configuration : taking the disks larger than n *) Definition clshift m n (c : configuration (m + n)) : configuration m := [ffun i => c (tlshift n i)]. (* Sanity check *)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)

cmerge (clshift c) (crshift c) = c
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)

cmerge (clshift c) (crshift c) = c
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
i:ordinal_finType (m + n)

match tsplit i with | inl j => clshift c j | inr j => crshift c j end = c i
by case: tsplitP => [] j iE; rewrite !ffunE /=; congr fun_of_fin; apply/val_eqP/eqP. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k

tsplit (tlshift m x) = inl x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k

tsplit (tlshift m x) = inl x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k
j:'I_m
jE:x + m = j

inr j = inl x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x, k1:'I_k
x + m == k1 + m -> inl k1 = inl x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x, k1:'I_k

x + m == k1 + m -> inl k1 = inl x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x, k1:'I_k
H:x = k1

inl k1 = inl x
by congr (inl _); apply: val_inj. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k

tsplit (trshift m x) = inr x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k

tsplit (trshift m x) = inr x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x, j:'I_k
jE:x = j

inr j = inr x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k
k1:'I_m
xE:x = k1 + k
inl k1 = inr x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
k, m:nat
x:'I_k
k1:'I_m
xE:x = k1 + k

inl k1 = inr x
by have := ltn_ord x; rewrite xE ltnNge leq_addl. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n

on_top (trshift m x) (cmerge c1 c2) = on_top x c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n

on_top (trshift m x) (cmerge c1 c2) = on_top x c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n

(forall d1 : ordinal_finType (m + n), cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 -> trshift m x <= d1) -> forall d1 : ordinal_finType n, c2 x = c2 d1 -> x <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
(forall d1 : ordinal_finType n, c2 x = c2 d1 -> x <= d1) -> forall d1 : ordinal_finType (m + n), cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 -> trshift m x <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
Hx:forall d1 : ordinal_finType (m + n), cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 -> trshift m x <= d1
d2:ordinal_finType n
cxEcd2:c2 x = c2 d2

x <= d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
(forall d1 : ordinal_finType n, c2 x = c2 d1 -> x <= d1) -> forall d1 : ordinal_finType (m + n), cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 -> trshift m x <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
Hx:forall d1 : ordinal_finType (m + n), cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 -> trshift m x <= d1
d2:ordinal_finType n
cxEcd2:c2 x = c2 d2

(cmerge c1 c2 (trshift m x) = cmerge c1 c2 (trshift m d2) -> trshift m x <= trshift m d2) -> x <= d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
(forall d1 : ordinal_finType n, c2 x = c2 d1 -> x <= d1) -> forall d1 : ordinal_finType (m + n), cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 -> trshift m x <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n

(forall d1 : ordinal_finType n, c2 x = c2 d1 -> x <= d1) -> forall d1 : ordinal_finType (m + n), cmerge c1 c2 (trshift m x) = cmerge c1 c2 d1 -> trshift m x <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
H:forall d1 : ordinal_finType n, c2 x = c2 d1 -> x <= d1
d:ordinal_finType (m + n)

c2 x = match tsplit d with | inl j => c1 j | inr j => c2 j end -> x <= d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
H:forall d1 : ordinal_finType n, c2 x = c2 d1 -> x <= d1
d:ordinal_finType (m + n)
j:'I_n
H1:c2 x = c2 j

x <= j
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
H:forall d1 : ordinal_finType n, c2 x = c2 d1 -> x <= d1
d:ordinal_finType (m + n)
k:'I_m
x <= k + n
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
x:'I_n
c1:configuration m
c2:configuration n
H:forall d1 : ordinal_finType n, c2 x = c2 d1 -> x <= d1
d:ordinal_finType (m + n)
k:'I_m

x <= k + n
by apply: leq_trans (ltnW _) (leq_addl _ _). Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m

move (cmerge c c1) (cmerge c c2) = move c1 c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m

move (cmerge c c1) (cmerge c c2) = move c1 c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H2d1:forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2
H3d1:on_top d1 c1
H4d1:on_top d1 c2

exists d1 : ordinal_finType (n + m), [/\ r (cmerge c c1 d1) (cmerge c c2 d1), forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2, on_top d1 (cmerge c c1) & on_top d1 (cmerge c c2)]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H2d1:forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2
H3d1:on_top d1 c1
H4d1:on_top d1 c2

r (cmerge c c1 (trshift n d1)) (cmerge c c2 (trshift n d1))
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H2d1:forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2
H3d1:on_top d1 c1
H4d1:on_top d1 c2
forall d2 : ordinal_finType (n + m), trshift n d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H2d1:forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2
H3d1:on_top d1 c1
H4d1:on_top d1 c2

forall d2 : ordinal_finType (n + m), trshift n d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H2d1:forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2
H3d1:on_top d1 c1
H4d1:on_top d1 c2
d2:ordinal_finType (n + m)
k:'I_m
d2E:d2 = k
H:trshift n d1 != d2

c1 k = c2 k
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType m
H1d1:r (c1 d1) (c2 d1)
H3d1:on_top d1 c1
H4d1:on_top d1 c2
d2:ordinal_finType (n + m)
k:'I_m
d2E:d2 = k

trshift n k == d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H1d1:r (cmerge c c1 d1) (cmerge c c2 d1)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)

exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)

r match tsplit d1 with | inl j => c j | inr j => c1 j end match tsplit d1 with | inl j => c j | inr j => c2 j end -> exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)

exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
H3d1:on_top d1 (cmerge c c1)
H4d1:on_top d1 (cmerge c c2)
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1

exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)

exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)

forall d2 : ordinal_finType m, j != d2 -> c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
d2:ordinal_finType m
kDd2:j != d2

c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
d2:ordinal_finType m
kDd2:j != d2

(d1 != trshift n d2 -> cmerge c c1 (trshift n d2) = cmerge c c2 (trshift n d2)) -> c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
d2:ordinal_finType m
kDd2:j != d2
H:d1 != trshift n d2 -> c1 d2 = c2 d2

c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
d2:ordinal_finType m
kDd2:j != d2

d1 != trshift n d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration n
c1, c2:configuration m
d1:ordinal_finType (n + m)
H2d1:forall d2 : ordinal_finType (n + m), d1 != d2 -> cmerge c c1 d2 = cmerge c c2 d2
j:'I_m
jE:d1 = j
H1x:r (c1 j) (c2 j)
d1E:trshift n j = d1
H3d1:on_top (trshift n j) (cmerge c c1)
H4d1:on_top (trshift n j) (cmerge c c2)
d2:ordinal_finType m

d1 == d2 -> j == d2
by rewrite jE. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration n)

path move (cmerge c1 c2) [seq cmerge c1 c | c <- cs] = path move c2 cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration n)

path move (cmerge c1 c2) [seq cmerge c1 c | c <- cs] = path move c2 cs
by elim: cs c2 => //= c3 cs IH c2; rewrite move_merger IH. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n

connect move c1 c2 -> connect move (cmerge c c1) (cmerge c c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n

connect move c1 c2 -> connect move (cmerge c c1) (cmerge c c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
x:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
Hp:path move (cmerge c c1) [seq cmerge c c0 | c0 <- x]
Hl:c2 = last c1 x

connect move (cmerge c c1) (cmerge c c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
x:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
Hp:path move (cmerge c c1) [seq cmerge c c0 | c0 <- x]
Hl:c2 = last c1 x

cmerge c c2 = last (cmerge c c1) [seq cmerge c c0 | c0 <- x]
by rewrite Hl [RHS]last_map. Qed. (* this should be equality *)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n

connect move c1 c2 -> `d[cmerge c c1, cmerge c c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n

connect move c1 c2 -> `d[cmerge c c1, cmerge c c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
p1:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
p1H:gpath move c1 c2 p1

`d[cmerge c c1, cmerge c c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
p1:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
p1H:gpath move c1 c2 p1

`d[cmerge c c1, cmerge c c2]_move <= size [seq cmerge c i | i <- p1]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration m
c1, c2:configuration n
p1:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
p1H:gpath move c1 c2 p1

last (cmerge c c1) [seq cmerge c i | i <- p1] = cmerge c c2
by rewrite [LHS]last_map (gpath_last p1H). Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m

cdisjoint c1 c2 -> on_top d c1 -> on_top (tlshift n d) (cmerge c1 c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m

cdisjoint c1 c2 -> on_top d c1 -> on_top (tlshift n d) (cmerge c1 c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
c1Dc2:cdisjoint c1 c2
dTc:forall d1 : ordinal_finType m, c1 d = c1 d1 -> d <= d1
d1:ordinal_finType (m + n)

cmerge c1 c2 (tlshift n d) = cmerge c1 c2 d1 -> tlshift n d <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
c1Dc2:cdisjoint c1 c2
dTc:forall d1 : ordinal_finType m, c1 d = c1 d1 -> d <= d1
d1:ordinal_finType (m + n)

c1 d = match tsplit d1 with | inl j => c1 j | inr j => c2 j end -> d + n <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
c1Dc2:cdisjoint c1 c2
dTc:forall d1 : ordinal_finType m, c1 d = c1 d1 -> d <= d1
d1:ordinal_finType (m + n)
j:'I_m
c1dc1j:c1 d = c1 j

d + n <= j + n
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
c1Dc2:cdisjoint c1 c2
dTc:forall d1 : ordinal_finType m, c1 d = c1 d1 -> d <= d1
d1:ordinal_finType (m + n)
j:'I_n
c1dc1j:c1 d = c2 j
d + n <= j
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:disk m
c1Dc2:cdisjoint c1 c2
dTc:forall d1 : ordinal_finType m, c1 d = c1 d1 -> d <= d1
d1:ordinal_finType (m + n)
j:'I_n
c1dc1j:c1 d = c2 j

d + n <= j
by have /cdisjointP/(_ d j)/eqP[] := c1Dc2. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:'I_m

on_top (tlshift n d) (cmerge c1 c2) -> on_top d c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:'I_m

on_top (tlshift n d) (cmerge c1 c2) -> on_top d c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:'I_m
dTc:forall d1 : ordinal_finType (m + n), cmerge c1 c2 (tlshift n d) = cmerge c1 c2 d1 -> tlshift n d <= d1
d1:ordinal_finType m
Hc:c1 d = c1 d1

d <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
d:'I_m
dTc:forall d1 : ordinal_finType (m + n), cmerge c1 c2 (tlshift n d) = cmerge c1 c2 d1 -> tlshift n d <= d1
d1:ordinal_finType m
Hc:c1 d = c1 d1

(cmerge c1 c2 (tlshift n d) = cmerge c1 c2 (tlshift n d1) -> tlshift n d <= tlshift n d1) -> d <= d1
by rewrite !ffunE !tsplit_tlshift /= leq_add2r; apply. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n

move (cmerge c1 c) (cmerge c2 c) -> move c1 c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n

move (cmerge c1 c) (cmerge c2 c) -> move c1 c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H1x:r (cmerge c1 c x) (cmerge c2 c x)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
H3x:on_top x (cmerge c1 c)
H4x:on_top x (cmerge c2 c)

exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
H3x:on_top x (cmerge c1 c)
H4x:on_top x (cmerge c2 c)

r match tsplit x with | inl j => c1 j | inr j => c j end match tsplit x with | inl j => c2 j | inr j => c j end -> exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
H3x:on_top x (cmerge c1 c)
H4x:on_top x (cmerge c2 c)
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)

exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
H3x:on_top x (cmerge c1 c)
H4x:on_top x (cmerge c2 c)
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x

exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)

exists d1 : ordinal_finType m, [/\ r (c1 d1) (c2 d1), forall d2 : ordinal_finType m, d1 != d2 -> c1 d2 = c2 d2, on_top d1 c1 & on_top d1 c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)

forall d2 : ordinal_finType m, k != d2 -> c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
d2:ordinal_finType m
kDd2:k != d2

c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
d2:ordinal_finType m
kDd2:k != d2

(x != tlshift n d2 -> cmerge c1 c (tlshift n d2) = cmerge c2 c (tlshift n d2)) -> c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
d2:ordinal_finType m
kDd2:k != d2
H:x != tlshift n d2 -> c1 d2 = c2 d2

c1 d2 = c2 d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
d2:ordinal_finType m
kDd2:k != d2

x != tlshift n d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
x:ordinal_finType (m + n)
H2x:forall d2 : ordinal_finType (m + n), x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
k:'I_m
kE:x = k + n
J1x:r (c1 k) (c2 k)
xE:tlshift n k = x
H3x:on_top (tlshift n k) (cmerge c1 c)
H4x:on_top (tlshift n k) (cmerge c2 c)
d2:ordinal_finType m

x == d2 + n -> k == d2
by rewrite kE eqn_add2r. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n

cdisjoint c1 c -> cdisjoint c2 c -> move c1 c2 -> move (cmerge c1 c) (cmerge c2 c)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n

cdisjoint c1 c -> cdisjoint c2 c -> move c1 c2 -> move (cmerge c1 c) (cmerge c2 c)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType m, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2

exists d1 : ordinal_finType (m + n), [/\ r (cmerge c1 c d1) (cmerge c2 c d1), forall d2 : ordinal_finType (m + n), d1 != d2 -> cmerge c1 c d2 = cmerge c2 c d2, on_top d1 (cmerge c1 c) & on_top d1 (cmerge c2 c)]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType m, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2

r (cmerge c1 c (tlshift n x)) (cmerge c2 c (tlshift n x))
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType m, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType (m + n), tlshift n x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType m, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2

forall d2 : ordinal_finType (m + n), tlshift n x != d2 -> cmerge c1 c d2 = cmerge c2 c d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType m, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
d2:ordinal_finType (m + n)
k:'I_m
d2E:d2 = k + n
H:tlshift n x != d2

c1 k = c2 k
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration m
c:configuration n
c1Dc:cdisjoint c1 c
c2Dc:cdisjoint c2 c
x:ordinal_finType m
H1x:r (c1 x) (c2 x)
H3x:on_top x c1
H4x:on_top x c2
d2:ordinal_finType (m + n)
k:'I_m
d2E:d2 = k + n

tlshift n k == d2
by apply/eqP/val_eqP/eqP. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration m)

path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs] -> path move c1 cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration m)

path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs] -> path move c1 cs
by elim: cs c1 => //= c3 cs IH c1 /andP[/move_mergel-> /IH]. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration m)

all ((cdisjoint (n:=n))^~ c2) (c1 :: cs) -> path move c1 cs -> path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration m
c2:configuration n
cs:seq (configuration m)

all ((cdisjoint (n:=n))^~ c2) (c1 :: cs) -> path move c1 cs -> path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c2:configuration n
c3:configuration m
cs:seq (configuration m)
IH:forall c1 : configuration m, cdisjoint c1 c2 && all ((cdisjoint (n:=n))^~ c2) cs -> path move c1 cs -> path move (cmerge c1 c2) [seq cmerge i c2 | i <- cs]
c1:configuration m
c1Dc2:cdisjoint c1 c2
c3Dc2:cdisjoint c3 c2
Dcs:all ((cdisjoint (n:=n))^~ c2) cs

cdisjoint c3 c2 && all ((cdisjoint (n:=n))^~ c2) cs
by rewrite c3Dc2. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)

on_top d c -> match tsplit d with | inl d1 => on_top d1 (clshift c) | inr d2 => on_top d2 (crshift c) end
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)

on_top d c -> match tsplit d with | inl d1 => on_top d1 (clshift c) | inr d2 => on_top d2 (crshift c) end
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)

on_top (tunsplit (tsplit d)) c -> match tsplit d with | inl d1 => on_top d1 (clshift c) | inr d2 => on_top d2 (crshift c) end
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)
j:'I_n
dE:d = j
dT:forall d1 : 'I_(m + n), c (trshift m j) = c d1 -> j <= d1
d1:ordinal_finType n
H:c (trshift m j) = c (trshift m d1)

j <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)
j:'I_m
dE:d = j + n
dT:forall d1 : 'I_(m + n), c (tlshift n j) = c d1 -> j + n <= d1
d1:ordinal_finType m
H:c (tlshift n j) = c (tlshift n d1)
j <= d1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
d:disk (m + n)
j:'I_m
dE:d = j + n
dT:forall d1 : 'I_(m + n), c (tlshift n j) = c d1 -> j + n <= d1
d1:ordinal_finType m
H:c (tlshift n j) = c (tlshift n d1)

j <= d1
by have /= := dT _ H; rewrite leq_add2r. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)

move c1 c2 -> clshift c1 != clshift c2 -> move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)

move c1 c2 -> clshift c1 != clshift c2 -> move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)

[/\ r (c1 x) (c2 x), forall d2 : ordinal_finType (m + n), x != d2 -> c1 d2 = c2 d2, on_top x c1 & on_top x c2] -> clshift c1 != clshift c2 -> move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)

[/\ r (c1 (tunsplit (tsplit x))) (c2 (tunsplit (tsplit x))), forall d2 : ordinal_finType (m + n), tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2, on_top (tunsplit (tsplit x)) c1 & on_top (tunsplit (tsplit x)) c2] -> clshift c1 != clshift c2 -> move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)

(on_top x c1 -> match tsplit x with | inl d1 => on_top d1 (clshift c1) | inr d2 => on_top d2 (crshift c1) end) -> [/\ r (c1 (tunsplit (tsplit x))) (c2 (tunsplit (tsplit x))), forall d2 : ordinal_finType (m + n), tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2, on_top (tunsplit (tsplit x)) c1 & on_top (tunsplit (tsplit x)) c2] -> clshift c1 != clshift c2 -> move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)

(on_top x c2 -> match tsplit x with | inl d1 => on_top d1 (clshift c2) | inr d2 => on_top d2 (crshift c2) end) -> (on_top x c1 -> match tsplit x with | inl d1 => on_top d1 (clshift c1) | inr d2 => on_top d2 (crshift c1) end) -> [/\ r (c1 (tunsplit (tsplit x))) (c2 (tunsplit (tsplit x))), forall d2 : ordinal_finType (m + n), tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2, on_top (tunsplit (tsplit x)) c1 & on_top (tunsplit (tsplit x)) c2] -> clshift c1 != clshift c2 -> move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:clshift c1 != clshift c2

move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
i:ordinal_finType m

clshift c1 i = clshift c2 i
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
i:ordinal_finType m

c1 (tlshift n i) = c2 (tlshift n i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
i:ordinal_finType m

~~ (j <= i + n) || ~~ (i + n <= j)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2

move (clshift c1) (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
d2:ordinal_finType m
kDd2:k != d2

c1 (tlshift n d2) = c2 (tlshift n d2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
d2:ordinal_finType m
kDd2:k != d2

c1 (tlshift n d2) = c2 (tlshift n d2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
d2:ordinal_finType m
kDd2:k != d2

tlshift n k != tlshift n d2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2

on_top k (clshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2

on_top k (clshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2

x = tlshift n k
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2
on_top k (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2

on_top k (clshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:clshift c1 != clshift c2

x = tlshift n k
by apply/val_eqP/eqP => /=. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)

move c1 c2 -> crshift c1 != crshift c2 -> move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)

move c1 c2 -> crshift c1 != crshift c2 -> move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)

[/\ r (c1 x) (c2 x), forall d2 : ordinal_finType (m + n), x != d2 -> c1 d2 = c2 d2, on_top x c1 & on_top x c2] -> crshift c1 != crshift c2 -> move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)

[/\ r (c1 (tunsplit (tsplit x))) (c2 (tunsplit (tsplit x))), forall d2 : ordinal_finType (m + n), tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2, on_top (tunsplit (tsplit x)) c1 & on_top (tunsplit (tsplit x)) c2] -> crshift c1 != crshift c2 -> move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)

(on_top x c1 -> match tsplit x with | inl d1 => on_top d1 (clshift c1) | inr d2 => on_top d2 (crshift c1) end) -> [/\ r (c1 (tunsplit (tsplit x))) (c2 (tunsplit (tsplit x))), forall d2 : ordinal_finType (m + n), tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2, on_top (tunsplit (tsplit x)) c1 & on_top (tunsplit (tsplit x)) c2] -> crshift c1 != crshift c2 -> move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)

(on_top x c2 -> match tsplit x with | inl d1 => on_top d1 (clshift c2) | inr d2 => on_top d2 (crshift c2) end) -> (on_top x c1 -> match tsplit x with | inl d1 => on_top d1 (clshift c1) | inr d2 => on_top d2 (crshift c1) end) -> [/\ r (c1 (tunsplit (tsplit x))) (c2 (tunsplit (tsplit x))), forall d2 : ordinal_finType (m + n), tunsplit (tsplit x) != d2 -> c1 d2 = c2 d2, on_top (tunsplit (tsplit x)) c1 & on_top (tunsplit (tsplit x)) c2] -> crshift c1 != crshift c2 -> move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
c1Dc2:crshift c1 != crshift c2

move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
i:ordinal_finType n

crshift c1 i = crshift c2 i
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
i:ordinal_finType n

c1 (trshift m i) = c2 (trshift m i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
k:'I_m
xE:x = k + n
c2H:on_top x c2 -> on_top k (clshift c2)
c1H:on_top x c1 -> on_top k (clshift c1)
H1k:r (c1 (tlshift n k)) (c2 (tlshift n k))
H2k:forall d2 : 'I_(m + n), tlshift n k != d2 -> c1 d2 = c2 d2
H3k:on_top (tlshift n k) c1
H4k:on_top (tlshift n k) c2
i:ordinal_finType n

~~ (k + n <= i) || ~~ (i <= k + n)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2

move (crshift c1) (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
d2:ordinal_finType n
kDd2:j != d2

c1 (trshift m d2) = c2 (trshift m d2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
d2:ordinal_finType n
kDd2:j != d2

c1 (trshift m d2) = c2 (trshift m d2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2

on_top j (crshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2

on_top j (crshift c1)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2

x = trshift m j
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2
on_top j (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c2H:on_top x c2 -> on_top j (crshift c2)
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2

on_top j (crshift c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1, c2:configuration (m + n)
x:ordinal_finType (m + n)
j:'I_n
xE:x = j
c1H:on_top x c1 -> on_top j (crshift c1)
H1j:r (c1 (trshift m j)) (c2 (trshift m j))
H2j:forall d2 : 'I_(m + n), trshift m j != d2 -> c1 d2 = c2 d2
H3j:on_top (trshift m j) c1
H4j:on_top (trshift m j) c2
c1Dc2:crshift c1 != crshift c2

x = trshift m j
by apply/val_eqP/eqP => /=. Qed. Fixpoint rm_rep (A : eqType) (a : A) (s : seq A) := if s is b :: s1 then if a == b then rm_rep b s1 else b :: rm_rep b s1 else [::].
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A

subseq (rm_rep a s) s
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A

subseq (rm_rep a s) s
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s:seq A
IH:forall a : A, subseq (rm_rep a s) s
a:A

subseq (rm_rep a (b :: s)) (b :: s)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s:seq A
IH:forall a : A, subseq (rm_rep a s) s
a:A

subseq (rm_rep b s) (b :: s)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s:seq A
IH:forall a : A, subseq (rm_rep a s) s
a:A
subseq (b :: rm_rep b s) (b :: s)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s:seq A
IH:forall a : A, subseq (rm_rep a s) s
a:A

subseq (b :: rm_rep b s) (b :: s)
by rewrite /= eqxx IH. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A

{subset rm_rep a s <= s}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A

{subset rm_rep a s <= s}
by apply/mem_subseq/subseq_rm_rep. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A

size (rm_rep a s) <= size s
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A

size (rm_rep a s) <= size s
by apply/size_subseq/subseq_rm_rep. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a, b:A
s:seq A

size (rm_rep b s) <= size (rm_rep a (b :: s))
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a, b:A
s:seq A

size (rm_rep b s) <= size (rm_rep a (b :: s))
by rewrite /=; case: (_ == _) => //=. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
a:A
s1:{set A}
s2:seq A

{subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
a:A
s1:{set A}
s2:seq A

{subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
s1:{set A}
a:A
aS:{subset s1 <= [::]}

#|s1| <= 0
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
#|s1| <= size (if a == b then rm_rep b s2 else b :: rm_rep b s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
s1:{set A}
a:A
aS:{subset s1 <= [::]}
i:A

(i \in s1) = (i \in set0)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
#|s1| <= size (if a == b then rm_rep b s2 else b :: rm_rep b s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1

#|s1| <= size (if a == b then rm_rep b s2 else b :: rm_rep b s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aEb:a = b

#|s1| <= size (rm_rep b s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
#|s1| <= size (b :: rm_rep b s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aEb:a = b

{subset s1 <= s2}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
#|s1| <= size (b :: rm_rep b s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aEb:a = b
i:A
is1:i \in s1

(i == b) || (i \in s2) -> i \in s1 -> i \in s2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
#|s1| <= size (b :: rm_rep b s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b

#|s1| <= size (b :: rm_rep b s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bNIs1:b \notin s1

#|s1| <= (size (rm_rep b s2)).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
#|s1| <= (size (rm_rep b s2)).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bNIs1:b \notin s1

{subset s1 <= s2}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
#|s1| <= (size (rm_rep b s2)).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bNIs1:b \notin s1
i:A
is1:i \in s1

(i == b) || (i \in s2) -> i \in s1 -> i \in s2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
#|s1| <= (size (rm_rep b s2)).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1

#|s1| <= (size (rm_rep b s2)).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
IH:forall (s1 : {set A}) (a : A), {subset s1 <= s2} -> a \notin s1 -> #|s1| <= size (rm_rep a s2)
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1

#|s1 :\ b| <= size (rm_rep b s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
i:A

i \in s1 :\ b -> i \in s2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1
b \notin s1 :\ b
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:finType
b:A
s2:seq A
s1:{set A}
a:A
s1S:{subset s1 <= b :: s2}
aNIs1:a \notin s1
aDb:a <> b
bIs1:b \in s1

b \notin s1 :\ b
by rewrite !inE eqxx. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A

last a (rm_rep a s) = last a s
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s:seq A

last a (rm_rep a s) = last a s
by elim: s a => //= b l IH a; case: (_ =P _) => /= [->|_]; apply: IH. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s1, s2:seq A

rm_rep a (s1 ++ s2) = rm_rep a s1 ++ rm_rep (last a s1) s2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a:A
s1, s2:seq A

rm_rep a (s1 ++ s2) = rm_rep a s1 ++ rm_rep (last a s1) s2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s1:seq A
IH:forall (s2 : seq A) (a : A), rm_rep a (s1 ++ s2) = rm_rep a s1 ++ rm_rep (last a s1) s2
s2:seq A
a:A

(if a == b then rm_rep b (s1 ++ s2) else b :: rm_rep b (s1 ++ s2)) = (if a == b then rm_rep b s1 else b :: rm_rep b s1) ++ rm_rep (last b s1) s2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b:A
s1:seq A
IH:forall (s2 : seq A) (a : A), rm_rep a (s1 ++ s2) = rm_rep a s1 ++ rm_rep (last a s1) s2
s2:seq A
a:A
aDb:a <> b

b :: rm_rep b (s1 ++ s2) = b :: rm_rep b s1 ++ rm_rep (last b s1) s2
by congr (_ :: _); apply: IH. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a, b:A
s:seq_predType A

b != a -> b \in s -> b \in rm_rep a s
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
a, b:A
s:seq_predType A

b != a -> b \in s -> b \in rm_rep a s
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b, c:A
s:seq A
IH:forall a : A, b != a -> b \in s -> b \in rm_rep a s
a:A
bDa:b != a

(b == c) || (b \in s) -> b \in (if a == c then rm_rep c s else c :: rm_rep c s)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b, c:A
s:seq A
IH:forall a : A, b != a -> b \in s -> b \in rm_rep a s
a:A
bDa:b != a

b \in (if a == b then rm_rep b s else b :: rm_rep b s)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b, c:A
s:seq A
IH:forall a : A, b != a -> b \in s -> b \in rm_rep a s
a:A
bDa:b != a
bDc:b != c
bIs:b \in s
b \in (if a == c then rm_rep c s else c :: rm_rep c s)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
A:eqType
b, c:A
s:seq A
IH:forall a : A, b != a -> b \in s -> b \in rm_rep a s
a:A
bDa:b != a
bDc:b != c
bIs:b \in s

b \in (if a == c then rm_rep c s else c :: rm_rep c s)
by have := IH _ bDc bIs; case: (_ == _); rewrite // inE orbC => ->. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))

path move c cs -> path move (clshift c) (rm_rep (clshift c) [seq clshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))

path move c cs -> path move (clshift c) (rm_rep (clshift c) [seq clshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> path move (clshift c) (rm_rep (clshift c) [seq clshift i | i <- cs])
c:configuration (m + n)
cMc1:move c c1
c1Pcs:path move c1 cs

path move (clshift c) (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> path move (clshift c) (rm_rep (clshift c) [seq clshift i | i <- cs])
c:configuration (m + n)
cMc1:move c c1
c1Pcs:path move c1 cs
cDc1:clshift c != clshift c1

move (clshift c) (clshift c1) && path move (clshift c1) (rm_rep (clshift c1) [seq clshift i | i <- cs])
by rewrite move_clshift //=; apply: IH. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))

path move c cs -> path move (crshift c) (rm_rep (crshift c) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))

path move c cs -> path move (crshift c) (rm_rep (crshift c) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> path move (crshift c) (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
cMc1:move c c1
c1Pcs:path move c1 cs

path move (crshift c) (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> path move (crshift c) (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
cMc1:move c c1
c1Pcs:path move c1 cs
cDc1:crshift c != crshift c1

move (crshift c) (crshift c1) && path move (crshift c1) (rm_rep (crshift c1) [seq crshift i | i <- cs])
by rewrite move_crshift //=; apply: IH. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))

path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c:configuration (m + n)
cs:seq (configuration (m + n))

path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs

(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j

(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j

clshift c == clshift c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 = size (rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
i:ordinal_finType m

c (tlshift n i) = c1 (tlshift n i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 = size (rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
i:ordinal_finType m

d == i + n -> False
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 = size (rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j

(size cs).+1 = size (rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j

crshift c != crshift c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 = size (rm_rep (clshift c1) [seq clshift i | i <- cs]) + (size (rm_rep (crshift c1) [seq crshift i | i <- cs])).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
cE:c (trshift m j) = c1 (trshift m j)

False
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 = size (rm_rep (clshift c1) [seq clshift i | i <- cs]) + (size (rm_rep (crshift c1) [seq crshift i | i <- cs])).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
cE:c (trshift m j) = c1 (trshift m j)

c d = c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j
(size cs).+1 = size (rm_rep (clshift c1) [seq clshift i | i <- cs]) + (size (rm_rep (crshift c1) [seq crshift i | i <- cs])).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j

(size cs).+1 = size (rm_rep (clshift c1) [seq clshift i | i <- cs]) + (size (rm_rep (crshift c1) [seq crshift i | i <- cs])).+1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
j:'I_n
dE:d = j

size cs = size (rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n

(size cs).+1 = size (if clshift c == clshift c1 then rm_rep (clshift c1) [seq clshift i | i <- cs] else clshift c1 :: rm_rep (clshift c1) [seq clshift i | i <- cs]) + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n

clshift c != clshift c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = (size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
cE:c (tlshift n k) = c1 (tlshift n k)

False
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = (size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
cE:c (tlshift n k) = c1 (tlshift n k)

c d = c1 d
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = (size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n

(size cs).+1 = (size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 + size (if crshift c == crshift c1 then rm_rep (crshift c1) [seq crshift i | i <- cs] else crshift c1 :: rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n

crshift c == crshift c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = (size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 + size (rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
i:ordinal_finType n

c (trshift m i) = c1 (trshift m i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = (size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 + size (rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
i:ordinal_finType n

d == i -> False
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n
(size cs).+1 = (size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 + size (rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n

(size cs).+1 = (size (rm_rep (clshift c1) [seq clshift i | i <- cs])).+1 + size (rm_rep (crshift c1) [seq crshift i | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
c1:configuration (m + n)
cs:seq (configuration (m + n))
IH:forall c : configuration (m + n), path move c cs -> size cs = size (rm_rep (clshift c) [seq clshift i | i <- cs]) + size (rm_rep (crshift c) [seq crshift i | i <- cs])
c:configuration (m + n)
d:ordinal_finType (m + n)
d2H:r (c d) (c1 d)
d2H1:forall d2 : ordinal_finType (m + n), d != d2 -> c d2 = c1 d2
d2H2:on_top d c
d2H3:on_top d c1
c1Pcs:path move c1 cs
k:'I_m
dE:d = k + n

size cs = (fix add (n m : nat) {struct n} : nat := match n with | 0 => m | p.+1 => (add p m).+1 end) (size (rm_rep (clshift c1) [seq clshift i | i <- cs])) (size (rm_rep (crshift c1) [seq crshift i | i <- cs]))
by apply: IH. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)

connect move c1 c2 -> `d[clshift c1, clshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)

connect move c1 c2 -> `d[clshift c1, clshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

`d[clshift c1, clshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

size (rm_rep (clshift c1) [seq clshift i | i <- p]) <= size [seq clshift i | i <- p] -> `d[clshift c1, clshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

`d[clshift c1, clshift c2]_move <= size (rm_rep (clshift c1) [seq clshift i | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

last (clshift c1) (rm_rep (clshift c1) [seq clshift i | i <- p]) = clshift c2
by rewrite last_rm_rep last_map (gpath_last pH). Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)

connect move c1 c2 -> `d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)

connect move c1 c2 -> `d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

`d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

size (rm_rep (crshift c1) [seq crshift i | i <- p]) <= size [seq crshift i | i <- p] -> `d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

`d[crshift c1, crshift c2]_move <= size (rm_rep (crshift c1) [seq crshift i | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

last (crshift c1) (rm_rep (crshift c1) [seq crshift i | i <- p]) = crshift c2
by rewrite last_rm_rep last_map (gpath_last pH). Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)

connect move c1 c2 -> `d[clshift c1, clshift c2]_move + `d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)

connect move c1 c2 -> `d[clshift c1, clshift c2]_move + `d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

`d[clshift c1, clshift c2]_move + `d[crshift c1, crshift c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

`d[clshift c1, clshift c2]_move + `d[crshift c1, crshift c2]_move <= size (rm_rep (clshift c1) [seq clshift i | i <- p]) + size (rm_rep (crshift c1) [seq crshift i | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

`d[clshift c1, clshift c2]_move <= size (rm_rep (clshift c1) [seq clshift i | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p
`d[crshift c1, crshift c2]_move <= size (rm_rep (crshift c1) [seq crshift i | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

last (clshift c1) (rm_rep (clshift c1) [seq clshift i | i <- p]) = clshift c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p
`d[crshift c1, crshift c2]_move <= size (rm_rep (crshift c1) [seq crshift i | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

`d[crshift c1, crshift c2]_move <= size (rm_rep (crshift c1) [seq crshift i | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
c1, c2:configuration (m + n)
p:seq (finfun_finType (ordinal_finType (m + n)) (ordinal_finType q))
pH:gpath move c1 c2 p

last (crshift c1) (rm_rep (crshift c1) [seq crshift i | i <- p]) = crshift c2
by rewrite last_rm_rep last_map (gpath_last pH). Qed. Definition cliftrn m n p (c : configuration n) : configuration (m + n) := cmerge `c[p] c. Definition cliftr n : _ -> _ -> configuration n.+1 := @cliftrn 1 n. Notation " ↑[ c ]_ p" := (cliftr p c) (at level 5, format "↑[ c ]_ p"). Definition cliftln m n p (c : configuration m) : configuration (m + n) := cmerge c `c[p]. Definition cliftl n c p : configuration (n + 1) := (@cliftln n 1 c p).
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n

↑[c]_p ldisk = p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n

↑[c]_p ldisk = p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
j:'I_n
nE:n = j

c j = p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
t:'I_1
n = t + n -> `c[p] t = p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
t:'I_1

n = t + n -> `c[p] t = p
by rewrite ffunE. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
x:'I_n
c:configuration n

on_top (trshift m x) (cliftrn m p c) = on_top x c
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
x:'I_n
c:configuration n

on_top (trshift m x) (cliftrn m p c) = on_top x c
exact: on_top_merger. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n

move (cliftrn m p c1) (cliftrn m p c2) = move c1 c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n

move (cliftrn m p c1) (cliftrn m p c2) = move c1 c2
exact: move_merger. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c:configuration n
cs:seq (configuration n)

path move (cliftrn m p c) [seq cliftrn m p i | i <- cs] = path move c cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c:configuration n
cs:seq (configuration n)

path move (cliftrn m p c) [seq cliftrn m p i | i <- cs] = path move c cs
exact: path_merger. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n

connect move c1 c2 -> connect move (cliftrn m p c1) (cliftrn m p c2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n

connect move c1 c2 -> connect move (cliftrn m p c1) (cliftrn m p c2)
exact: connect_merger. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n

connect move c1 c2 -> `d[cliftrn m p c1, cliftrn m p c2]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n, m:nat
p:peg
c1, c2:configuration n

connect move c1 c2 -> `d[cliftrn m p c1, cliftrn m p c2]_move <= `d[c1, c2]_move
exact: gdist_merger. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n

move ↑[c1]_p ↑[c2]_p = move c1 c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n

move ↑[c1]_p ↑[c2]_p = move c1 c2
by exact: move_liftrn 1 p c1 c2. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg

↑[`c[p]]_p = `c[p]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg

↑[`c[p]]_p = `c[p]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
i:ordinal_finType n.+1

match tsplit i with | inl j => `c[p] j | inr j => `c[p] j end = p
by case: tsplitP => [j|k]; rewrite !ffunE. Qed. Definition cunliftr {n} (c : configuration n.+1) : configuration n := @crshift 1 n c. Notation " ↓[ c ]" := (cunliftr c) (at level 5, format "↓[ c ]").
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg

cancel (cliftr p) (cunliftr : configuration n.+1 -> configuration n)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg

cancel (cliftr p) (cunliftr : configuration n.+1 -> configuration n)
by move=> c; apply/ffunP => i; rewrite !ffunE tsplit_trshift. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1

↑[↓[c]]_(c ldisk) = c
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1

↑[↓[c]]_(c ldisk) = c
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
i:ordinal_finType n.+1

match tsplit i with | inl j => `c[c ldisk] j | inr j => ↓[c] j end = c i
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
i:ordinal_finType n.+1
j:'I_1
iE:i = j + n

n = i
by rewrite iE; case: (j) => [] []. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg

injective (cliftr p)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg

injective (cliftr p)
by move=> c1 c2 c1Ec2; rewrite -[c1](cliftrK p) c1Ec2 cliftrK. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
T1, T2:eqType
f:T1 -> T2
s1, s2:seq T1

injective f -> ([seq f i | i <- s1] == [seq f i | i <- s2]) = (s1 == s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
T1, T2:eqType
f:T1 -> T2
s1, s2:seq T1

injective f -> ([seq f i | i <- s1] == [seq f i | i <- s2]) = (s1 == s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
T1, T2:eqType
f:T1 -> T2
a:T1
s1:seq T1
IH:forall s2 : seq T1, injective f -> ([seq f i | i <- s1] == [seq f i | i <- s2]) = (s1 == s2)
b:T1
s2:seq T1
fInj:injective f

(f a :: [seq f i | i <- s1] == f b :: [seq f i | i <- s2]) = (a :: s1 == b :: s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
T1, T2:eqType
f:T1 -> T2
a:T1
s1:seq T1
IH:forall s2 : seq T1, injective f -> ([seq f i | i <- s1] == [seq f i | i <- s2]) = (s1 == s2)
b:T1
s2:seq T1
fInj:injective f

(f a == f b) && (s1 == s2) = (a == b) && (s1 == s2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
T1, T2:eqType
f:T1 -> T2
a:T1
s1:seq T1
IH:forall s2 : seq T1, injective f -> ([seq f i | i <- s1] == [seq f i | i <- s2]) = (s1 == s2)
b:T1
s2:seq T1
fInj:injective f

a <> b -> (f a == f b) && (s1 == s2) = false && (s1 == s2)
by case: (f a =P f b) => [/fInj|//]. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
cs1, cs2:seq (configuration n)

([seq ↑[i]_p | i <- cs1] == [seq ↑[i]_p | i <- cs2]) = (cs1 == cs2)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
cs1, cs2:seq (configuration n)

([seq ↑[i]_p | i <- cs1] == [seq ↑[i]_p | i <- cs2]) = (cs1 == cs2)
by apply/map_eqr/cliftr_inj. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg

↓[`c[p]] = `c[p]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg

↓[`c[p]] = `c[p]
by apply/ffunP => i; rewrite !ffunE. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg

s2f ([set i | c i == p] :\ ord_max) = s2f [set i | ↓[c] i == p]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg

s2f ([set i | c i == p] :\ ord_max) = s2f [set i | ↓[c] i == p]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType

(i \in s2f ([set i | c i == p] :\ ord_max)) = (i \in s2f [set i | ↓[c] i == p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1

j \in [set i | c i == p] :\ ord_max -> i = j -> exists2 x : 'I_n, x \in [set i | ↓[c] i == p] & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] -> i = j -> exists2 x : 'I_n.+1, x \in [set i | c i == p] :\ ord_max & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j

exists2 x : 'I_n, x \in [set i | ↓[c] i == p] & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] -> i = j -> exists2 x : 'I_n.+1, x \in [set i | c i == p] :\ ord_max & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j

j < n
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j
jLn:j < n
exists2 x : 'I_n, x \in [set i | ↓[c] i == p] & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] -> i = j -> exists2 x : 'I_n.+1, x \in [set i | c i == p] :\ ord_max & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
cjEp:c j = p
jEi:i = j
jDn:j != n

j < n
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j
jLn:j < n
exists2 x : 'I_n, x \in [set i | ↓[c] i == p] & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] -> i = j -> exists2 x : 'I_n.+1, x \in [set i | c i == p] :\ ord_max & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j
jLn:j < n

exists2 x : 'I_n, x \in [set i | ↓[c] i == p] & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] -> i = j -> exists2 x : 'I_n.+1, x \in [set i | c i == p] :\ ord_max & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n.+1
jDn:j != ord_max
cjEp:c j = p
jEi:i = j
jLn:j < n

c (trshift 1 (Ordinal jLn)) = p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
j \in [set i | ↓[c] i == p] -> i = j -> exists2 x : 'I_n.+1, x \in [set i | c i == p] :\ ord_max & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n

j \in [set i | ↓[c] i == p] -> i = j -> exists2 x : 'I_n.+1, x \in [set i | c i == p] :\ ord_max & i = x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
p:peg
i:nat_choiceType
j:'I_n
cjEp:c (trshift 1 j) = p
iEj:i = j

trshift 1 j \in [set i | c i == p] :\ ord_max
by rewrite !inE cjEp -val_eqE //= neq_ltn ltn_ord /=. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
s:seq peg

codom c \subset s -> codom ↓[c] \subset s
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
s:seq peg

codom c \subset s -> codom ↓[c] \subset s
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
s:seq peg
H:codom c \subset s
i:ordinal_finType q
j:ordinal_finType n

↓[c] j \in s
by rewrite ffunE; apply: (subsetP H); apply: codom_f. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1

move c1 c2 -> c1 ldisk != c2 ldisk -> ↓[c1] = ↓[c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1

move c1 c2 -> c1 ldisk != c2 ldisk -> ↓[c1] = ↓[c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
c1Mc2:move c1 c2
c10Dc20:c1 ldisk != c2 ldisk

↓[c1] = ↓[c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
c1Mc2:move c1 c2
c10Dc20:c1 ldisk != c2 ldisk
i:ordinal_finType n

c1 (trshift 1 i) = c2 (trshift 1 i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
i:ordinal_finType n

ldisk != trshift 1 i
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
i:ordinal_finType n

n != i
by rewrite eqn_leq negb_and -ltnNge ltn_ord. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1

c1 ldisk = c2 ldisk -> move ↓[c1] ↓[c2] = move c1 c2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1

c1 ldisk = c2 ldisk -> move ↓[c1] ↓[c2] = move c1 c2
by move=> c1lEc2l; rewrite -(@move_liftr _ (c1 ldisk)) {2}c1lEc2l !cunliftrK. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n
cs:seq (configuration n)

path move (last c cs) (rev (belast c cs)) = path move c cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n
cs:seq (configuration n)

path move (last c cs) (rev (belast c cs)) = path move c cs
by rewrite rev_path; apply: eq_path => c1 c2; exact: move_sym. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
cs:seq (configuration n)

path move ↑[c]_p [seq ↑[i]_p | i <- cs] = path move c cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c:configuration n
cs:seq (configuration n)

path move ↑[c]_p [seq ↑[i]_p | i <- cs] = path move c cs
by apply: (@path_merger 1). Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n

connect move c1 c2 -> connect move ↑[c1]_p ↑[c2]_p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n

connect move c1 c2 -> connect move ↑[c1]_p ↑[c2]_p
by apply: (@connect_merger 1). Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n

connect move c1 c2 -> `d[↑[c1]_p, ↑[c2]_p]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
p:peg
c1, c2:configuration n

connect move c1 c2 -> `d[↑[c1]_p, ↑[c2]_p]_move <= `d[c1, c2]_move
by apply: (@gdist_merger 1). Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)

(forall c1 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c1 \in cs -> c1 ldisk = c ldisk) -> path move ↓[c] [seq ↓[i] | i <- cs] = path move c cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)

(forall c1 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c1 \in cs -> c1 ldisk = c ldisk) -> path move ↓[c] [seq ↓[i] | i <- cs] = path move c cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
H:forall c1 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c1 \in cs -> c1 ldisk = c ldisk

path move ↓[c] [seq ↓[i] | i <- cs] = path move c cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
H:forall c1 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c1 \in cs -> c1 ldisk = c ldisk

path move ↑[↓[c]]_(c ldisk) [seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]] = path move c cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
H:forall c1 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c1 \in cs -> c1 ldisk = c ldisk

path move c [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i | i <- cs] = path move c cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
H:forall c1 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c1 \in cs -> c1 ldisk = c ldisk

[seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i | i <- cs] = cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c, a:configuration n.+1
cs:seq (configuration n.+1)
IH:(forall c1 : {ffun 'I_n.+1 -> 'I_q}, c1 \in cs -> c1 ldisk = c ldisk) -> [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i | i <- cs] = cs
H:forall c1 : {ffun 'I_n.+1 -> 'I_q}, c1 \in a :: cs -> c1 ldisk = c ldisk

↑[↓[a]]_(c ldisk) :: [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i | i <- cs] = a :: cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c, a:configuration n.+1
cs:seq (configuration n.+1)
IH:(forall c1 : {ffun 'I_n.+1 -> 'I_q}, c1 \in cs -> c1 ldisk = c ldisk) -> [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i | i <- cs] = cs
H:forall c1 : {ffun 'I_n.+1 -> 'I_q}, c1 \in a :: cs -> c1 ldisk = c ldisk

↑[↓[a]]_(a ldisk) :: [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i | i <- cs] = a :: cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c, a:configuration n.+1
cs:seq (configuration n.+1)
IH:(forall c1 : {ffun 'I_n.+1 -> 'I_q}, c1 \in cs -> c1 ldisk = c ldisk) -> [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i | i <- cs] = cs
H:forall c1 : {ffun 'I_n.+1 -> 'I_q}, c1 \in a :: cs -> c1 ldisk = c ldisk
a \in a :: cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c, a:configuration n.+1
cs:seq (configuration n.+1)
IH:(forall c1 : {ffun 'I_n.+1 -> 'I_q}, c1 \in cs -> c1 ldisk = c ldisk) -> [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i | i <- cs] = cs
H:forall c1 : {ffun 'I_n.+1 -> 'I_q}, c1 \in a :: cs -> c1 ldisk = c ldisk

a \in a :: cs
by rewrite inE eqxx. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)

path move c cs -> path move ↓[c] (rm_rep ↓[c] [seq ↓[i] | i <- cs])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)

path move c cs -> path move ↓[c] (rm_rep ↓[c] [seq ↓[i] | i <- cs])
by move=> H; apply: path_crshift. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1

connect move c1 c2 -> `d[↓[c1], ↓[c2]]_move <= `d[c1, c2]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1

connect move c1 c2 -> `d[↓[c1], ↓[c2]]_move <= `d[c1, c2]_move
by move=> H; apply: gdist_crshift. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1

irreflexive r -> connect move c1 c2 -> c1 ldisk = c2 ldisk -> `d[c1, c2]_move = `d[↓[c1], ↓[c2]]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1

irreflexive r -> connect move c1 c2 -> c1 ldisk = c2 ldisk -> `d[c1, c2]_move = `d[↓[c1], ↓[c2]]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Cc2:connect move c1 c2
c1Ec2:c1 ldisk = c2 ldisk

`d[c1, c2]_move <= `d[↓[c1], ↓[c2]]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Cc2:connect move c1 c2
c1Ec2:c1 ldisk = c2 ldisk

`d[↑[↓[c1]]_(c1 ldisk), ↑[↓[c2]]_(c1 ldisk)]_move <= `d[↓[c1], ↓[c2]]_move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Cc2:connect move c1 c2
c1Ec2:c1 ldisk = c2 ldisk

connect move ↓[c1] ↓[c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Ec2:c1 ldisk = c2 ldisk
p:seq (finfun_finType (ordinal_finType n.+1) (ordinal_finType q))
pH:path move c1 p
c2E:c2 = last c1 p

connect move ↓[c1] ↓[c2]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Ec2:c1 ldisk = c2 ldisk
p:seq (finfun_finType (ordinal_finType n.+1) (ordinal_finType q))
pH:path move c1 p
c2E:c2 = last c1 p

path move ↓[c1] (rm_rep ↓[c1] [seq ↓[i] | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Ec2:c1 ldisk = c2 ldisk
p:seq (finfun_finType (ordinal_finType n.+1) (ordinal_finType q))
pH:path move c1 p
c2E:c2 = last c1 p
↓[c2] = last ↓[c1] (rm_rep ↓[c1] [seq ↓[i] | i <- p])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:configuration n.+1
ir:irreflexive r
c1Ec2:c1 ldisk = c2 ldisk
p:seq (finfun_finType (ordinal_finType n.+1) (ordinal_finType q))
pH:path move c1 p
c2E:c2 = last c1 p

↓[c2] = last ↓[c1] (rm_rep ↓[c1] [seq ↓[i] | i <- p])
by rewrite last_rm_rep c2E last_map. Qed.
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
p:peg

cliftrn m p `c[p] = `c[p]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
m, n:nat
p:peg

cliftrn m p `c[p] = `c[p]
by apply/ffunP => i; rewrite !ffunE; case: tsplitP => j; rewrite !ffunE. Qed. (* case distinction that depends if the largest disk has move *) (* if it has not moved, we get the path on the unlifted configuration *) (* uf it has moved, we get the decomposition till the first move *) Inductive pathS_spec (n : nat) (c : configuration n.+1) (cs : seq (configuration n.+1)) : forall (b : bool), Type := pathS_specW : forall (p := c ldisk) (c1 := ↓[c]) (cs1 := [seq ↓[i] | i <- cs]), cs = [seq ↑[i]_p | i <- cs1] -> path move c1 cs1 -> pathS_spec c cs true | pathS_spec_move : forall (p1 := c ldisk) p2 cs1 cs2 (c1 := ↓[c]) (c2 := ↑[last c1 cs1]_p2), p1 != p2 -> r p1 p2 -> cs = [seq ↑[i]_p1 | i <- cs1] ++ c2 :: cs2 -> path move c1 cs1 -> move ↑[last c1 cs1]_p1 c2 -> path move c2 cs2 -> pathS_spec c cs true | pathS_spec_false : pathS_spec c cs false. (* Inversion theorem on a path for disk n.+1 *)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)

pathS_spec c cs (path move c cs)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)

pathS_spec c cs (path move c cs)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs, forall x : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), ~~ f x}

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs, forall x : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), ~~ f x}

cs = [seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs, forall x : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), ~~ f x}
csE:cs = [seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]]
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs, forall x : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), ~~ f x}

[seq x | x <- cs] = [seq ([eta cliftr (c ldisk)] \o [eta cunliftr]) i | i <- cs]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs, forall x : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), ~~ f x}
csE:cs = [seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]]
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs, forall x : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), ~~ f x}
x:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)

x = ↑[↓[x]]_(x ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs, forall x : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), ~~ f x}
csE:cs = [seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]]
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs, forall x : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), ~~ f x}
csE:cs = [seq ↑[i]_(c ldisk) | i <- [seq ↓[i] | i <- cs]]

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hn:{in cs, forall x : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), ~~ f x}

path move ↓[c] [seq ↓[i] | i <- cs]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk

p1 != p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
c2:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)

c2 \in lcs1 -> c2 ldisk = p1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
c2:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
c2Ilcs1p:c2 \in lcs1

c2 \in lcs1 -> c2 ldisk = p1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
c2:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
c2Ilcs1p:c2 \in lcs1

~~ f (nth c cs (index c2 lcs1)) -> c2 ldisk = p1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
c2:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
c2Ilcs1p:c2 \in lcs1

nth c cs (index c2 lcs1) ldisk = c ldisk -> c2 ldisk = p1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)

lcs1 = [seq ↑[i]_p1 | i <- cs1]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)

[seq x | x <- lcs1] = [seq ([eta cliftr p1] \o cunliftr) i | i <- lcs1]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
x:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
H:x ldisk = p1

x = ([eta cliftr p1] \o cunliftr) x
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]

cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2

move (last c lcs1) lc1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1

lc1 = ↑[last c1 cs1]_p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1

lc1 = ↑[last c1 cs1]_(lc1 ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1

last c lcs1 ldisk != lc1 ldisk
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
lc1 = ↑[last c1 cs1]_(lc1 ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
a:configuration n.+1
l:seq (configuration n.+1)

last a l \in a :: l
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
lc1 = ↑[last c1 cs1]_(lc1 ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk

lc1 = ↑[last c1 cs1]_(lc1 ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk

↑[↓[lc1]]_(lc1 ldisk) = ↑[↓[last c lcs1]]_(lc1 ldisk)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk

↓[lc1] = ↓[last c lcs1]
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
i:ordinal_finType n

lc1 (trshift 1 i) = last c lcs1 (trshift 1 i)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
i:ordinal_finType n

ldisk != trshift 1 i
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
Hd:last c lcs1 ldisk != lc1 ldisk
i:ordinal_finType n

n != i
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2

move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2

↑[last ↓[c] cs1]_p1 = last c lcs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
move (last c lcs1) ↑[last c1 cs1]_p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2

move (last c lcs1) ↑[last c1 cs1]_p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

pathS_spec c cs true
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

r (c ldisk) p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
cs = [seq ↑[i]_(c ldisk) | i <- cs1] ++ ↑[last ↓[c] cs1]_p2 :: ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

r (c ldisk) p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
cs = [seq ↑[i]_(c ldisk) | i <- cs1] ++ ↑[last ↓[c] cs1]_p2 :: ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

(↑[last c1 cs1]_p1 ldisk != ↑[last c1 cs1]_p2 ldisk -> r (↑[last c1 cs1]_p1 ldisk) (↑[last c1 cs1]_p2 ldisk)) -> r (c ldisk) p2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
cs = [seq ↑[i]_(c ldisk) | i <- cs1] ++ ↑[last ↓[c] cs1]_p2 :: ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

cs = [seq ↑[i]_(c ldisk) | i <- cs1] ++ ↑[last ↓[c] cs1]_p2 :: ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

cs = [seq ↑[i]_(c ldisk) | i <- cs1] ++ ↑[last ↓[c] cs1]_p2 :: ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 ?Goal
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 cs2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

path move ↓[c] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 cs2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

path move c lcs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2
path move ↑[last ↓[c] cs1]_p2 cs2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

path move ↑[last ↓[c] cs1]_p2 cs2
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)
Hp:path move c cs
f:=fun c1 : configuration n.+1 => c1 ldisk != c ldisk:configuration n.+1 -> bool
Hh:has f cs
n1:=find f cs:nat
lc1:=nth c cs n1:configuration n.+1
p1:=c ldisk:(fun=> peg) ldisk
p2:=lc1 ldisk:(fun=> peg) ldisk
p1Dp2:p1 != p2
c1:=↓[c]:configuration n
lcs1:=take n1 cs:seq (configuration n.+1)
cs2:=drop n1.+1 cs:seq (configuration n.+1)
slcs1:size lcs1 = n1
Plcs1:forall c2 : finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q), c2 \in lcs1 -> c2 ldisk = p1
cs1:=[seq ↓[i] | i <- lcs1]:seq (configuration n)
lcs1E:lcs1 = [seq ↑[i]_p1 | i <- cs1]
csE:cs = [seq ↑[i]_p1 | i <- cs1] ++ lc1 :: cs2
Hm:move (last c lcs1) lc1
lc1E:lc1 = ↑[last c1 cs1]_p2
Hm1:move ↑[last c1 cs1]_p1 ↑[last c1 cs1]_p2

path move lc1 cs2
by move: Hp; rewrite csE cat_path /= => /and3P[]. Qed. (* we can restrict a path from n.+1 to n by removing all the moves of the *) (* largest disk *)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)

path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
cs:seq (configuration n.+1)

path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1

{cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[c] & size cs' <= 0 ?= iff ([::] == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
{cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c1 cs] & size cs' <= (size cs).+1 ?= iff (c1 :: cs == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])

{cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c1 cs] & size cs' <= (size cs).+1 ?= iff (c1 :: cs == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dEcd:c ldisk = c1 ldisk

{cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c1 cs] & size cs' <= (size cs).+1 ?= iff (c1 :: cs == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
{cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c1 cs] & size cs' <= (size cs).+1 ?= iff (c1 :: cs == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dEcd:c ldisk = c1 ldisk

move ↓[c] ↓[c1] && path move ↓[c1] cs1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dEcd:c ldisk = c1 ldisk
(size cs1).+1 <= (size cs).+1 ?= iff (c1 :: cs == ↑[↓[c1]]_ (c ldisk) :: [ seq ↑[i]_ (c ldisk) | i <- cs1])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
{cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c1 cs] & size cs' <= (size cs).+1 ?= iff (c1 :: cs == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dEcd:c ldisk = c1 ldisk

(size cs1).+1 <= (size cs).+1 ?= iff (c1 :: cs == ↑[↓[c1]]_(c ldisk) :: [seq ↑[i]_(c ldisk) | i <- cs1])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
{cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c1 cs] & size cs' <= (size cs).+1 ?= iff (c1 :: cs == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk

{cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c1 cs] & size cs' <= (size cs).+1 ?= iff (c1 :: cs == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk

{cs' : seq (configuration n) | [/\ path move ↓[c1] cs', last ↓[c1] cs' = ↓[last c1 cs] & size cs' <= (size cs).+1 ?= iff (c1 :: cs == [seq ↑[i]_(c ldisk) | i <- cs'])]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk

size cs1 <= (size cs).+1 ?= iff (c1 :: cs == [seq ↑[i]_(c ldisk) | i <- cs1])
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1:configuration n.+1
cs:seq (configuration n.+1)
IH:forall c : configuration n.+1, path move c cs -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' <= size cs ?= iff (cs == [seq ↑[i]_ (c ldisk) | i <- cs'])]}
c:configuration n.+1
cMc1:move c c1
cs1:seq (configuration n)
c1Pcs1:path move ↓[c1] cs1
lccs1Mlc1cs:last ↓[c1] cs1 = ↓[last c1 cs]
S:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c1 ldisk) | i <- cs1])
c1dDcd:c ldisk != c1 ldisk
H:c1 :: cs = [seq ↑[i]_(c ldisk) | i <- cs1]

size cs1 == (size cs).+1
by rewrite -[_.+1]/(size (c1 :: cs)) H size_map. Qed. (* we can restrict a path from n.+1 to n *)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
cs:seq (configuration n.+1)

path move c cs -> c1 \in cs -> c1 ldisk != c ldisk -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' < size cs]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
cs:seq (configuration n.+1)

path move c cs -> c1 \in cs -> c1 ldisk != c ldisk -> {cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' < size cs]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
c1Ics:c1 \in cs
c1dDcd:c1 ldisk != c ldisk

{cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' < size cs]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
c1Ics:c1 \in cs
c1dDcd:c1 ldisk != c ldisk
cs1:seq (configuration n)
H1:path move ↓[c] cs1
H2:last ↓[c] cs1 = ↓[last c cs]
H3:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c ldisk) | i <- cs1])

{cs' : seq (configuration n) | [/\ path move ↓[c] cs', last ↓[c] cs' = ↓[last c cs] & size cs' < size cs]}
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
c1Ics:c1 \in cs
c1dDcd:c1 ldisk != c ldisk
cs1:seq (configuration n)
H1:path move ↓[c] cs1
H2:last ↓[c] cs1 = ↓[last c cs]
H3:size cs1 <= size cs ?= iff (cs == [seq ↑[i]_(c ldisk) | i <- cs1])

size cs1 < size cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
c1Ics:c1 \in cs
c1dDcd:c1 ldisk != c ldisk
cs1:seq (configuration n)
H1:path move ↓[c] cs1
H2:last ↓[c] cs1 = ↓[last c cs]
cs1Ecs:cs = [seq ↑[i]_(c ldisk) | i <- cs1]

size cs1 == size cs -> size cs1 < size cs
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
c1Ics:c1 \in cs
cs1:seq (configuration n)
H1:path move ↓[c] cs1
H2:last ↓[c] cs1 = ↓[last c cs]
cs1Ecs:cs = [seq ↑[i]_(c ldisk) | i <- cs1]

c1 ldisk = c ldisk
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c:configuration n.+1
c1:finfun_eqType (ordinal_finType n.+1) (ordinal_eqType q)
cs:seq (configuration n.+1)
cPcs:path move c cs
cs1:seq (configuration n)
H1:path move ↓[c] cs1
H2:last ↓[c] cs1 = ↓[last c cs]
cs1Ecs:cs = [seq ↑[i]_(c ldisk) | i <- cs1]
x:finfun_eqType (ordinal_finType n) (ordinal_eqType q)
xIcs1:x \in cs1

↑[x]_(c ldisk) ldisk = c ldisk
by rewrite cliftr_ldisk. Qed. (* connect is symmetric *) (* there should be a shorter proof since move n is symmetric *)
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat

connect_sym move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat

connect_sym move
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType q)

connect move c1 c2 = connect move c2 c1
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType q)
p:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
H1:path move c1 p
H2:c2 = last c1 p

exists2 p : seq (finfun_finType (ordinal_finType n) (ordinal_finType q)), path move c2 p & c1 = last c2 p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType q)
p:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
H1:path move c2 p
H2:c1 = last c2 p
exists2 p : seq (finfun_finType (ordinal_finType n) (ordinal_finType q)), path move c1 p & c2 = last c1 p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType q)
p:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
H1:path move c1 p
H2:c2 = last c1 p

c1 = last c2 (rev (belast c1 p))
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType q)
p:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
H1:path move c2 p
H2:c1 = last c2 p
exists2 p : seq (finfun_finType (ordinal_finType n) (ordinal_finType q)), path move c1 p & c2 = last c1 p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType q)
p:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
H1:path move c2 p
H2:c1 = last c2 p

exists2 p : seq (finfun_finType (ordinal_finType n) (ordinal_finType q)), path move c1 p & c2 = last c1 p
q:nat
r:rel peg
irH:irreflexive r
symH:symmetric r
n:nat
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType q)
p:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
H1:path move c2 p
H2:c1 = last c2 p

c2 = last c1 (rev (belast c2 p))
by case: (p) H2 => [->//|c3 p1 _]; rewrite rev_cons last_rcons. Qed. End GHanoi. Arguments perfect {q n}. Arguments cunliftr {q n}. Notation " ↑[ c ]_ p" := (cliftr p c) (at level 5, format "↑[ c ]_ p"). Notation " ↓[ c ]" := (cunliftr c) (at level 5, format "↓[ c ]"). Notation "`c[ p ] " := (perfect p) (format "`c[ p ]", at level 5). Notation "`c[ p , n ] " := ((perfect p) : configuration _ n) (format "`c[ p , n ]", at level 5).
k:nat
d:disk 1
c:configuration k 1

on_top d c
k:nat
d:disk 1
c:configuration k 1

on_top d c
by apply/on_topP=> [] [] [] //=; case: d => [] []. Qed.
n, k:nat
p1, p2:peg k

(`c[p1 , n.+1] == `c[p2]) = (p1 == p2)
n, k:nat
p1, p2:peg k

(`c[p1 , n.+1] == `c[p2]) = (p1 == p2)
n, k:nat
p1, p2:peg k
cp1Ecp2:`c[p1] = `c[p2]

p1 = p2
n, k:nat
p1, p2:peg k
cp1Ecp2:`c[p1] = `c[p2]

`c[p1] sdisk = p2
by rewrite cp1Ecp2 ffunE. Qed. Section PLift. Variables n q : nat. Variables i : disk q.+1. Variable r1 : rel (disk q). Variable r2 : rel (disk q.+1). Let p := lift i. Hypothesis r2Rr1 : forall i j, r2 (p i) (p j) = r1 i j. Definition plift (c : configuration q n) : configuration q.+1 n := [ffun j => p (c j)].
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1:configuration q n
x:disk n

on_top x (plift c1) = on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1:configuration q n
x:disk n

on_top x (plift c1) = on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1:configuration q n
x:disk n
H:forall d1 : ordinal_finType n, plift c1 x = plift c1 d1 -> x <= d1
d:ordinal_finType n
H2:c1 x = c1 d

p (c1 x) = p (c1 d)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1:configuration q n
x:disk n
H:forall d1 : ordinal_finType n, c1 x = c1 d1 -> x <= d1
d:ordinal_finType n
H2:p (c1 x) = p (c1 d)
c1 x = c1 d
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1:configuration q n
x:disk n
H:forall d1 : ordinal_finType n, c1 x = c1 d1 -> x <= d1
d:ordinal_finType n
H2:p (c1 x) = p (c1 d)

c1 x = c1 d
by apply: lift_inj H2. Qed.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n

move r2 (plift c1) (plift c2) = move r1 c1 c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n

move r2 (plift c1) (plift c2) = move r1 c1 c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)

r1 (c1 x) (c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)

r1 (c1 x) (c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)

forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)

forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)

on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)

on_top x c1
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)
on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)

on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r2 (plift c1 x) (plift c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
H3x:on_top x (plift c1)
H4x:on_top x (plift c2)

on_top x c2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2

r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2

r2 (plift c1 x) (plift c2 x)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2

forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2

forall d2 : ordinal_finType n, x != d2 -> plift c1 d2 = plift c2 d2
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2

on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2

on_top x (plift c1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2
on_top x (plift c2)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
x:ordinal_finType n
H1x:r1 (c1 x) (c2 x)
H2x:forall d2 : ordinal_finType n, x != d2 -> c1 d2 = c2 d2
H3x:on_top x c1
H4x:on_top x c2

on_top x (plift c2)
by rewrite plift_on_top. Qed.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1:configuration q n
cs:seq (configuration q n)

path (move r2) (plift c1) [seq plift i | i <- cs] = path (move r1) c1 cs
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1:configuration q n
cs:seq (configuration q n)

path (move r2) (plift c1) [seq plift i | i <- cs] = path (move r1) c1 cs
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c2:configuration q n
cs:seq (configuration q n)
IH:forall c1 : configuration q n, path (move r2) (plift c1) [seq plift i | i <- cs] = path (move r1) c1 cs
c1:configuration q n

move r2 (plift c1) (plift c2) && path (move r2) (plift c2) [seq plift i | i <- cs] = move r1 c1 c2 && path (move r1) c2 cs
by rewrite plift_move IH. Qed.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n

connect (move r1) c1 c2 -> `d[plift c1, plift c2]_(move r2) <= `d[c1, c2]_(move r1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n

connect (move r1) c1 c2 -> `d[plift c1, plift c2]_(move r2) <= `d[c1, c2]_(move r1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
p1:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1

`d[plift c1, plift c2]_(move r2) <= `d[c1, c2]_(move r1)
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
p1:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1

`d[plift c1, plift c2]_(move r2) <= size [seq plift i | i <- p1]
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
c1, c2:configuration q n
p1:seq (finfun_finType (ordinal_finType n) (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1

last (plift c1) [seq plift i | i <- p1] = plift c2
by rewrite last_map (gpath_last p1H). Qed.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
p1:peg q

plift `c[p1] = `c[lift i p1]
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
p1:peg q

plift `c[p1] = `c[lift i p1]
by apply/ffunP => j; rewrite !ffunE. Qed.
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
m:nat
c:configuration q n

cdisjoint (plift c) `c[i , m]
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
m:nat
c:configuration q n

cdisjoint (plift c) `c[i , m]
n, q:nat
i:disk q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
p:=lift i:'I_q.+1.-1 -> 'I_q.+1
r2Rr1:forall i j : 'I_q.+1.-1, r2 (p i) (p j) = r1 i j
m:nat
c:configuration q n
i1:ordinal_finType n
j1:ordinal_finType m

bump i (c i1) != i
by rewrite eq_sym neq_bump. Qed. End PLift. Section Crlift. Variable q : nat. Variable p : peg q.+1. Variable r1 : rel (disk q). Variable r2 : rel (disk q.+1). Hypothesis r2Irr : irreflexive r2. Hypothesis r1Rr2 : forall i j : disk q, r1 i j = r2 (lift p i) (lift p j).
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m

move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2)) = move r1 c1 c2
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m

move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2)) = move r1 c1 c2
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2

move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2))
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2))
move r1 c1 c2
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2

cdisjoint (plift p c1) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
cdisjoint (plift p c2) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
move r2 (plift p c1) (plift p c2)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2))
move r1 c1 c2
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2

cdisjoint (plift p c1) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
cdisjoint (plift p c2) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
move r2 (plift p c1) (plift p c2)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2))
move r1 c1 c2
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2

cdisjoint (plift p c2) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
move r2 (plift p c1) (plift p c2)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2))
move r1 c1 c2
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2

cdisjoint (plift p c2) `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2
move r2 (plift p c1) (plift p c2)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2))
move r1 c1 c2
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r1 c1 c2

move r2 (plift p c1) (plift p c2)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2))
move r1 c1 c2
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2))

move r1 c1 c2
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
H:move r2 (cliftln n p (plift p c1)) (cliftln n p (plift p c2))

move r2 (plift p c1) (plift p c2) -> move r1 c1 c2
by rewrite (@plift_move _ _ _ r1). Qed.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c:configuration q m
cs:seq (configuration q m)

path (move r2) (cliftln n p (plift p c)) [seq (cliftln n p \o plift p) i | i <- cs] = path (move r1) c cs
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c:configuration q m
cs:seq (configuration q m)

path (move r2) (cliftln n p (plift p c)) [seq (cliftln n p \o plift p) i | i <- cs] = path (move r1) c cs
by elim: cs c => //= c1 cs1 IH c; rewrite move_liftln IH. Qed.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m

connect (move r1) c1 c2 -> connect (move r2) (cliftln n p (plift p c1)) (cliftln n p (plift p c2))
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m

connect (move r1) c1 c2 -> connect (move r2) (cliftln n p (plift p c1)) (cliftln n p (plift p c2))
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
x:seq (finfun_finType (ordinal_finType m) (ordinal_finType q))
Hp:path (move r2) (cliftln n p (plift p c1)) [seq (cliftln n p \o plift p) i | i <- x]
Hl:c2 = last c1 x

connect (move r2) (cliftln n p (plift p c1)) (cliftln n p (plift p c2))
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
x:seq (finfun_finType (ordinal_finType m) (ordinal_finType q))
Hp:path (move r2) (cliftln n p (plift p c1)) [seq (cliftln n p \o plift p) i | i <- x]
Hl:c2 = last c1 x

cliftln n p (plift p c2) = last (cliftln n p (plift p c1)) [seq (cliftln n p \o plift p) i | i <- x]
by rewrite Hl [RHS]last_map. Qed.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m

connect (move r1) c1 c2 -> `d[cliftln n p (plift p c1), cliftln n p (plift p c2)]_ (move r2) <= `d[c1, c2]_(move r1)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m

connect (move r1) c1 c2 -> `d[cliftln n p (plift p c1), cliftln n p (plift p c2)]_ (move r2) <= `d[c1, c2]_(move r1)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
p1:seq (finfun_finType (ordinal_finType m) (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1

`d[cliftln n p (plift p c1), cliftln n p (plift p c2)]_ (move r2) <= `d[c1, c2]_(move r1)
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
p1:seq (finfun_finType (ordinal_finType m) (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1

`d[cliftln n p (plift p c1), cliftln n p (plift p c2)]_ (move r2) <= size [seq (cliftln n p \o plift p) i | i <- p1]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
m, n:nat
c1, c2:configuration q m
p1:seq (finfun_finType (ordinal_finType m) (ordinal_finType q))
p1H:gpath (move r1) c1 c2 p1

last (cliftln n p (plift p c1)) [seq (cliftln n p \o plift p) i | i <- p1] = cliftln n p (plift p c2)
by rewrite [LHS]last_map (gpath_last p1H). Qed.
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
n, m:nat
p1:peg q.+1

cliftln n p `c[p1] = cliftrn m p1 `c[p]
q:nat
p:peg q.+1
r1:rel (disk q)
r2:rel (disk q.+1)
r2Irr:irreflexive r2
r1Rr2:forall i j : disk q, r1 i j = r2 (lift p i) (lift p j)
n, m:nat
p1:peg q.+1

cliftln n p `c[p1] = cliftrn m p1 `c[p]
by []. Qed. End Crlift. (******************************************************************************) (* Other peg *) (******************************************************************************) Definition opeg n (p1 p2 : peg n) := odflt (if p1 <= p2 then p1 else p2) [pick i | (i != p1) && (i != p2)].
n:nat
p1, p2:peg n

opeg p1 p2 = opeg p2 p1
n:nat
p1, p2:peg n

opeg p1 p2 = opeg p2 p1
n:nat
p1, p2:peg n
H:p1 = p2

odflt p1 [pick i | i != p1 & i != p2] = odflt p2 [pick i | i != p2 & i != p1]
n:nat
p1, p2:peg n
H:p1 = p2

p1 = p2
by apply/val_eqP/eqP. Qed.
n:nat
p1, p2:peg n.+3

opeg p1 p2 != p1
n:nat
p1, p2:peg n.+3

opeg p1 p2 != p1
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0

odflt (if p1 <= p2 then p1 else p2) None != p1
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0
p3, p4:peg n.+3

(p3 == p4) = (val p3 == val p4)
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3, (p3 == p4) = (val p3 == val p4)
odflt (if p1 <= p2 then p1 else p2) None != p1
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3, (p3 == p4) = (val p3 == val p4)

odflt (if p1 <= p2 then p1 else p2) None != p1
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3, (p3 == p4) = (val p3 == val p4)

(inord 2 != p1) && (inord 2 != p2) = false -> (inord 1 != p1) && (inord 1 != p2) = false -> (sdisk != p1) && (sdisk != p2) = false -> odflt (if p1 <= p2 then p1 else p2) None != p1
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3, (p3 == p4) = (val p3 == val p4)

(2 != p1) && (2 != p2) = false -> (1 != p1) && (1 != p2) = false -> (0 != p1) && (0 != p2) = false -> (if p1 <= p2 then p1 else p2) != p1
by case: {HD}p1 => [] [|[|[|p1 Hp1]]] /=; case: p2 => [] [|[|[|p2 Hp2]]]. Qed.
n:nat
p1, p2:peg n.+3

opeg p1 p2 != p2
n:nat
p1, p2:peg n.+3

opeg p1 p2 != p2
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0

odflt (if p1 <= p2 then p1 else p2) None != p2
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0
p3, p4:peg n.+3

(p3 == p4) = (val p3 == val p4)
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3, (p3 == p4) = (val p3 == val p4)
odflt (if p1 <= p2 then p1 else p2) None != p2
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3, (p3 == p4) = (val p3 == val p4)

odflt (if p1 <= p2 then p1 else p2) None != p2
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3, (p3 == p4) = (val p3 == val p4)

(inord 2 != p1) && (inord 2 != p2) = false -> (inord 1 != p1) && (inord 1 != p2) = false -> (sdisk != p1) && (sdisk != p2) = false -> odflt (if p1 <= p2 then p1 else p2) None != p2
n:nat
p1, p2:peg n.+3
HD:(fun i : ordinal_finType n.+3 => (i != p1) && (i != p2)) =1 xpred0
D:forall p3 p4 : peg n.+3, (p3 == p4) = (val p3 == val p4)

(2 != p1) && (2 != p2) = false -> (1 != p1) && (1 != p2) = false -> (0 != p1) && (0 != p2) = false -> (if p1 <= p2 then p1 else p2) != p2
by case: {HD}p1 => [] [|[|[|p1 Hp1]]] /=; case: p2 => [] [|[|[|p2 Hp2]]]. Qed. Notation "`p[ p1 , p2 ] " := (opeg p1 p2) (format "`p[ p1 , p2 ]", at level 5).
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q

hrel p1 p2 -> p1 != p3 -> p2 != p3 -> move hrel ↑[`c[p3 , n]]_p1 ↑[`c[p3]]_p2
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q

hrel p1 p2 -> p1 != p3 -> p2 != p3 -> move hrel ↑[`c[p3 , n]]_p1 ↑[`c[p3]]_p2
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

move hrel ↑[`c[p3 , n]]_p1 ↑[`c[p3]]_p2
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

cdisjoint `c[p1] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
cdisjoint `c[p2] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel `c[p1] `c[p2]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

cdisjoint `c[p1] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
cdisjoint `c[p2] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel `c[p1] `c[p2]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

cdisjoint `c[p2] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel `c[p1] `c[p2]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

cdisjoint `c[p2] `c[p3]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
move hrel `c[p1] `c[p2]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

move hrel `c[p1] `c[p2]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

hrel (`c[p1] ldisk) (`c[p2] ldisk)
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
forall d2 : ordinal_finType 1, ldisk != d2 -> `c[p1] d2 = `c[p2] d2
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

forall d2 : ordinal_finType 1, ldisk != d2 -> `c[p1] d2 = `c[p2] d2
by case => [] []. Qed.
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q

irreflexive hrel -> hrel p1 p2 -> p1 != p3 -> p2 != p3 -> `d[↑[`c[p3 , n]]_p1, ↑[`c[p3]]_p2]_(move hrel) = 1
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q

irreflexive hrel -> hrel p1 p2 -> p1 != p3 -> p2 != p3 -> `d[↑[`c[p3 , n]]_p1, ↑[`c[p3]]_p2]_(move hrel) = 1
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

`d[↑[`c[p3 , n]]_p1, ↑[`c[p3]]_p2]_(move hrel) = 1
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

`d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel) <= 1
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
0 < `d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel)
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

`d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel) <= size [:: ↑[`c[p3 , n]]_p2]
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
0 < `d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel)
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

move hrel ↑[`c[p3]]_p1 ↑[`c[p3]]_p2 && true
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
0 < `d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel)
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3

0 < `d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel)
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
E:`d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_(move hrel) = 0

0 < 0
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
E:↑[`c[p3]]_p1 = ↑[`c[p3]]_p2

0 < 0
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
E:↑[`c[p3]]_p1 = ↑[`c[p3]]_p2

↑[`c[p3]]_p1 ldisk = p1 -> 0 < 0
q, n:nat
hrel:rel (peg q)
p1, p2:peg q
p3:ordinal_eqType q
hirr:irreflexive hrel
p1Rp2:hrel p1 p2
p1Dp3:p1 != p3
p2Dp3:p2 != p3
E:↑[`c[p3]]_p1 = ↑[`c[p3]]_p2
p2Ep1:p2 = p1

0 < 0
by have := hirr p1; rewrite -{2}p2Ep1 p1Rp2. Qed. (*****************************************************************************) (* Regular relation *) (*****************************************************************************) Section Rrel. Variable n : nat. Definition rrel : rel (peg n) := [rel x y | x != y].
n:nat

irreflexive rrel
by move=> x; apply/eqP. Qed.
n:nat

symmetric rrel
by move=> x y; rewrite /rrel /= eq_sym. Qed. Definition rmove m : rel (configuration n m) := move rrel. End Rrel. Section Srel. Variable n : nat. Definition srel : rel (peg n) := [rel x y : peg n | (x != y) && (x * y == 0)].
n:nat

irreflexive srel
by move=> x; apply/idP/negP; rewrite negb_and eqxx. Qed.
n:nat

symmetric srel
by move=> x y; rewrite /srel /= mulnC eq_sym. Qed. Definition smove m : rel (configuration n m) := move srel. End Srel. (******************************************************************************) (* Linear relation *) (******************************************************************************) Section Lrel. Variable n : nat. Definition lrel : rel (peg n) := [rel x y : peg n | (x.+1 == y) || (y.+1 == x)].
n:nat

irreflexive lrel
n:nat

irreflexive lrel
by move=> k; rewrite /lrel /= (gtn_eqF (leqnn _)). Qed.
n:nat

symmetric lrel
n:nat

symmetric lrel
by move=> x y; rewrite /lrel /= orbC. Qed. Definition lmove m : rel (configuration n m) := move lrel. End Lrel. Arguments rmove {n m}. Arguments lmove {n m}. Arguments smove {n m}.
p, n:nat
c1, c2:configuration p.+3 n

connect rmove c1 c2
p, n:nat
c1, c2:configuration p.+3 n

connect rmove c1 c2
p:nat
c1, c2:configuration p.+3 0

connect rmove c1 c2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
connect rmove c1 c2
p:nat
c1, c2:configuration p.+3 0

c1 = c2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
connect rmove c1 c2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1

connect rmove c1 c2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1

connect rmove ↑[↓[c1]]_(c1 ldisk) ↑[↓[c2]]_(c2 ldisk)
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk

connect rmove ↑[↓[c1]]_p1 ↑[↓[c2]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk

connect rmove ↑[↓[c1]]_p1 ↑[↓[c2]]_p1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
connect rmove ↑[↓[c1]]_p1 ↑[↓[c2]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2

connect rmove ↑[↓[c1]]_p1 ↑[↓[c2]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

connect rmove ↑[↓[c1]]_p1 ↑[↓[c2]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

connect rmove ↑[↓[c1]]_p1 ↑[`c[p3]]_p1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p1 ↑[↓[c2]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

connect (move (rrel (n:=p.+3))) ↓[c1] `c[p3]
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p1 ↑[↓[c2]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

connect rmove ↑[`c[p3]]_p1 ↑[↓[c2]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

connect rmove ↑[`c[p3]]_p2 ↑[↓[c2]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p1 ↑[`c[p3]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

connect (move (rrel (n:=p.+3))) `c[p3] ↓[c2]
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
connect rmove ↑[`c[p3]]_p1 ↑[`c[p3]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

connect rmove ↑[`c[p3]]_p1 ↑[`c[p3]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

rmove ↑[`c[p3]]_p1 ↑[`c[p3]]_p2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

p1 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, connect rmove c1 c2
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

p2 != p3
rewrite eq_sym; apply: opegDr. Qed.
p, n:nat
c1, c2:configuration p.+3 n

`d[c1, c2]_rmove <= (2 ^ n).-1
p, n:nat
c1, c2:configuration p.+3 n

`d[c1, c2]_rmove <= (2 ^ n).-1
p:nat
c1, c2:configuration p.+3 0

`d[c1, c2]_rmove <= (2 ^ 0).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
`d[c1, c2]_rmove <= (2 ^ n.+1).-1
p:nat
c1, c2:configuration p.+3 0

c1 = c2
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
`d[c1, c2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1

`d[c1, c2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1

`d[↑[↓[c1]]_(c1 ldisk), ↑[↓[c2]]_(c2 ldisk)]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk

`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk

`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p1]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk

`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p1]_rmove <= ?Goal0
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
?Goal0 <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk

connect (move (rrel (n:=p.+3))) ↓[c1] ↓[c2]
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
`d[↓[c1], ↓[c2]]_(move (rrel (n:=p.+3))) <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk

`d[↓[c1], ↓[c2]]_(move (rrel (n:=p.+3))) <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk

(2 ^ n).-1 <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk

2 ^ n <= 2 ^ n.+1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2

`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

`d[↑[↓[c1]]_p1, ↑[↓[c2]]_p2]_rmove <= ?Goal
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
?Goal <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove + `d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n.+1).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3

`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove + `d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n + 2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove + `d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n + 2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove + `d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1 + (2 ^ n).-1.+1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[↑[↓[c1]]_p1, ↑[`c[p3]]_p1]_rmove <= ?Goal0
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
?Goal0 <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

connect (move (rrel (n:=p.+3))) ↓[c1] `c[p3]
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↓[c1], `c[p3]]_(move (rrel (n:=p.+3))) <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[↓[c1], `c[p3]]_(move (rrel (n:=p.+3))) <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[↑[`c[p3]]_p1, ↑[↓[c2]]_p2]_rmove <= ?Goal
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
?Goal <= (2 ^ n).-1.+1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[↑[`c[p3]]_p1, ↑[`c[p3]]_p2]_rmove + `d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1.+1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

irreflexive (rrel (n:=p.+3))
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p1 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

irreflexive (rrel (n:=p.+3))
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p1 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

p1 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

p1 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

p2 != p3
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[↑[`c[p3]]_p2, ↑[↓[c2]]_p2]_rmove <= ?Goal
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
?Goal <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

connect (move (rrel (n:=p.+3))) `c[p3] ↓[c2]
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n
`d[`c[p3], ↓[c2]]_(move (rrel (n:=p.+3))) <= (2 ^ n).-1
p, n:nat
IH:forall c1 c2 : configuration p.+3 n, `d[c1, c2]_rmove <= (2 ^ n).-1
c1, c2:configuration p.+3 n.+1
p1:=c1 ldisk:(fun=> peg p.+3) ldisk
p2:=c2 ldisk:(fun=> peg p.+3) ldisk
p1Dp2:p1 != p2
p3:=`p[p1, p2]:peg p.+3
tnP:0 < 2 ^ n

`d[`c[p3], ↓[c2]]_(move (rrel (n:=p.+3))) <= (2 ^ n).-1
by apply: IH. Qed. Definition sorted (s : seq nat) := forall i j, i < size s -> j < size s -> (nth 0 s i < nth 0 s j) = (i < j).
a:nat
s:seq nat

sorted (a :: s) -> sorted s
a:nat
s:seq nat

sorted (a :: s) -> sorted s
by move=> H i j iH jH; rewrite -[in RHS]ltnS -[in RHS]H. Qed.
i, j:nat

sorted (iota i j)
i, j:nat

sorted (iota i j)
i, j, i1, j1:nat
i1Lj:i1 < j
j1Lj:j1 < j

(nth 0 (iota i j) i1 < nth 0 (iota i j) j1) = (i1 < j1)
by rewrite !nth_iota // ltn_add2l. Qed.
a, b:nat
s:seq nat

sorted [:: a, b & s] -> sorted (a :: s)
a, b:nat
s:seq nat

sorted [:: a, b & s] -> sorted (a :: s)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
j:nat
iH:0 < size (a :: s)
jH:j.+1 < size (a :: s)

(a < nth 0 s j) = (0 < j.+1)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i:nat
iH:i.+1 < size (a :: s)
jH:0 < size (a :: s)
(nth 0 s i < a) = (i.+1 < 0)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i, j:nat
iH:i.+1 < size (a :: s)
jH:j.+1 < size (a :: s)
(nth 0 s i < nth 0 s j) = (i.+1 < j.+1)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
j:nat
iH:0 < size (a :: s)
jH:j.+1 < size (a :: s)

(a < nth 0 s j) = (0 < j.+1)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i:nat
iH:i.+1 < size (a :: s)
jH:0 < size (a :: s)
(nth 0 s i < a) = (i.+1 < 0)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i, j:nat
iH:i.+1 < size (a :: s)
jH:j.+1 < size (a :: s)
(nth 0 s i < nth 0 s j) = (i.+1 < j.+1)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i:nat
iH:i.+1 < size (a :: s)
jH:0 < size (a :: s)

(nth 0 s i < a) = (i.+1 < 0)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i, j:nat
iH:i.+1 < size (a :: s)
jH:j.+1 < size (a :: s)
(nth 0 s i < nth 0 s j) = (i.+1 < j.+1)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i:nat
iH:i.+1 < size (a :: s)
jH:0 < size (a :: s)

(nth 0 s i < a) = (i.+1 < 0)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i, j:nat
iH:i.+1 < size (a :: s)
jH:j.+1 < size (a :: s)
(nth 0 s i < nth 0 s j) = (i.+1 < j.+1)
a, b:nat
s:seq nat
Hs:sorted [:: a, b & s]
i, j:nat
iH:i.+1 < size (a :: s)
jH:j.+1 < size (a :: s)

(nth 0 s i < nth 0 s j) = (i.+1 < j.+1)
by rewrite (Hs i.+2 j.+2). Qed.
s:seq nat
p:pred nat

sorted s -> sorted [seq x <- s | p x]
s:seq nat
p:pred nat

sorted s -> sorted [seq x <- s | p x]
s:seq nat
p:pred nat
a:nat
s1:seq nat
i:nat

sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat, sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]

i < size (if p b then b :: [seq x <- s1 | p x] else [seq x <- s1 | p x]) -> a < nth 0 (if p b then b :: [seq x <- s1 | p x] else [seq x <- s1 | p x]) i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat, sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
pbT:p b

i < size (b :: [seq x <- s1 | p x]) -> a < nth 0 (b :: [seq x <- s1 | p x]) i
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat, sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
pbF:~~ p b
i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat, sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
abS:sorted [:: a, b & s1]
pbT:p b
i1:nat
sH:i1.+1 < (size [seq x <- s1 | p x]).+1

a < nth 0 [seq x <- s1 | p x] i1
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat, sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
pbF:~~ p b
i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
abS:sorted [:: a, b & s1]
pbT:p b
i1:nat
sH:i1.+1 < (size [seq x <- s1 | p x]).+1

sorted (a :: s1)
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat, sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
pbF:~~ p b
i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
IH:forall i : nat, sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
i:nat
abS:sorted [:: a, b & s1]
pbF:~~ p b

i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
s:seq nat
p:pred nat
a, b:nat
s1:seq nat
i:nat
abS:sorted [:: a, b & s1]
pbF:~~ p b

sorted (a :: s1)
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
sorted s -> sorted [seq x <- s | p x]
s:seq nat
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i

sorted s -> sorted [seq x <- s | p x]
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)

sorted (if p a then a :: [seq x <- s | p x] else [seq x <- s | p x])
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s

sorted (if p a then a :: [seq x <- s | p x] else [seq x <- s | p x])
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a

sorted (a :: [seq x <- s | p x])
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
iH, jH:0 < size (a :: [seq x <- s | p x])

(a < a) = (0 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
j:nat
iH:0 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(a < nth 0 [seq x <- s | p x] j) = (0 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
iH, jH:0 < size (a :: [seq x <- s | p x])

(a < a) = (0 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
j:nat
iH:0 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(a < nth 0 [seq x <- s | p x] j) = (0 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
j:nat
iH:0 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])

(a < nth 0 [seq x <- s | p x] j) = (0 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
j:nat
iH:0 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])

(a < nth 0 [seq x <- s | p x] j) = (0 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])

(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:0 < size (a :: [seq x <- s | p x])

(nth 0 [seq x <- s | p x] i < a) = (i.+1 < 0)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])
(nth 0 [seq x <- s | p x] i < nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
p:pred nat
F:forall (a : nat) (s1 : seq nat) (i : nat), sorted (a :: s1) -> i < size [seq x <- s1 | p x] -> a < nth 0 [seq x <- s1 | p x] i
a:nat
s:seq nat
IH:sorted s -> sorted [seq x <- s | p x]
aS:sorted (a :: s)
sS:sorted s
paT:p a
i, j:nat
iH:i.+1 < size (a :: [seq x <- s | p x])
jH:j.+1 < size (a :: [seq x <- s | p x])

(nth 0 [seq x <- s | p x] i < nth 0 [seq x <- s | p x] j) = (i.+1 < j.+1)
by rewrite ltnS (IH sS). Qed.
m:nat

enum 'I_m.+1 = [seq inord i | i <- iota 0 m.+1]
m:nat

enum 'I_m.+1 = [seq inord i | i <- iota 0 m.+1]
m:nat

enum 'I_m.+1 = [seq ([eta inord] \o nat_of_ord (n:=m.+1)) i | i <- ord_enum m.+1]
m:nat

ord_enum m.+1 = [seq ([eta inord] \o nat_of_ord (n:=m.+1)) i | i <- ord_enum m.+1]
m:nat
a:'I_m.+1
l:seq 'I_m.+1

a :: l = inord a :: l
by rewrite inord_val. Qed. (* To be reworked ! *)
m:nat
s:{set 'I_m}
i, j:'I_#|s|

(enum_val i < enum_val j) = (i < j)
m:nat
s:{set 'I_m}
i, j:'I_#|s|

(enum_val i < enum_val j) = (i < j)
s:{set 'I_0}

forall i j : 'I_#|s|, (enum_val i < enum_val j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j)
s:{set 'I_0}

forall i j : 'I_#|set0|, (enum_val i < enum_val j) = (i < j)
s:{set 'I_0}
s = set0
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j)
s:{set 'I_0}
m:nat
H:m < #|set0|
j:'I_#|set0|

False
s:{set 'I_0}
s = set0
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j)
s:{set 'I_0}

s = set0
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
(enum_val i < enum_val j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|

(enum_val i < enum_val j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|

j < size (enum s) -> i < size (enum s) -> (enum_val i < enum_val j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]

(nth (enum_default i) [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x] i < nth (enum_default j) [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]

(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth (enum_default j) [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]

(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k1, k2:nat

k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1

[seq i | i <- if inord k1 \in s then inord k1 :: [seq i <- [seq inord i0 | i0 <- iota k1.+1 k2] | i \in s] else [seq i <- [seq inord i0 | i0 <- iota k1.+1 k2] | i \in s]] = (if inord k1 \in s then k1 :: [seq i0 <- iota k1.+1 k2 | inord i0 \in s] else [seq i0 <- iota k1.+1 k2 | inord i0 \in s])
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1

inord k1 :: [seq i | i <- [seq inord i0 | i0 <- iota k1.+1 k2] & i \in s] = k1 :: [seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
[seq i | i <- [seq inord i0 | i0 <- iota k1.+1 k2] & i \in s] = [seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1

k1 :: [seq i | i <- [seq inord i0 | i0 <- iota k1.+1 k2] & i \in s] = k1 :: [seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
k1 < m.+1
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
[seq i | i <- [seq inord i0 | i0 <- iota k1.+1 k2] & i \in s] = [seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1

k1.+1 + k2 <= m.+1
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
k1 < m.+1
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
[seq i | i <- [seq inord i0 | i0 <- iota k1.+1 k2] & i \in s] = [seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1

k1 < m.+1
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1
[seq i | i <- [seq inord i0 | i0 <- iota k1.+1 k2] & i \in s] = [seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2:nat
IH:forall k1 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & i \in s] = [seq i0 <- iota k1 k2 | inord i0 \in s]
k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1

[seq i | i <- [seq inord i0 | i0 <- iota k1.+1 k2] & i \in s] = [seq i0 <- iota k1.+1 k2 | inord i0 \in s]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
k2, k1:nat
k1k2Lm:k1 + k2.+1 <= m.+1

k1.+1 + k2 <= m.+1
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]
(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]

(nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] i < nth 0 [seq i | i <- [seq inord i | i <- iota 0 m.+1] & mem s i] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]

(nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] i < nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]

j < size [seq i0 <- iota 0 m.+1 | mem s (inord i0)]
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]
j < size [seq i0 <- iota 0 m.+1 | mem s (inord i0)] -> (nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] i < nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]

j < size [seq i0 <- iota 0 m.+1 | mem s (inord i0)] -> (nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] i < nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]

i < size [seq i0 <- iota 0 m.+1 | mem s (inord i0)] -> j < size [seq i0 <- iota 0 m.+1 | mem s (inord i0)] -> (nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] i < nth 0 [seq i0 <- iota 0 m.+1 | mem s (inord i0)] j) = (i < j)
m:nat
s:{set 'I_m.+1}
i, j:'I_#|s|
iL:j < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
jL:i < size [seq x <- [seq inord i | i <- iota 0 m.+1] | mem s x]
F:forall k1 k2 : nat, k1 + k2 <= m.+1 -> [seq i | i <- [seq inord i0 | i0 <- iota k1 k2] & mem s i] = [seq i0 <- iota k1 k2 | mem s (inord i0)]

sorted (iota 0 m.+1)
by apply: sorted_iota. Qed. Section ISetd. (* Number of disks *) Variable n : nat. (* Subset of disks *) Variable sd : {set disk n}. (* Number of pegs *) Variable k : nat. (* relations on peg *) Variable rel : rel (peg k). Definition cset (c : configuration k n) : configuration k #|sd| := [ffun i => c (enum_val i)].
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd

on_top d c -> on_top (enum_rank_in dIsd d) (cset c)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd

on_top d c -> on_top (enum_rank_in dIsd d) (cset c)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1

on_top (enum_rank_in dIsd d) (cset c)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1

enum_rank_in dIsd d <= d1
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1

enum_rank_in dIsd d < d1
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1

enum_val d1 \in sd
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
d < enum_val d1
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1

d < enum_val d1
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1

(d != enum_val d1) && (d <= enum_val d1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
dEd1:d = enum_val d1

~~ true && (d <= enum_val d1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
d <= enum_val d1
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset c (enum_rank_in dIsd d) = cset c d1
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1

d <= enum_val d1
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:c d = c (enum_val d1)

d <= enum_val d1
by apply: dO. Qed.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n

move rel c1 c2 -> cset c1 != cset c2 -> move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n

move rel c1 c2 -> cset c1 != cset c2 -> move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2

move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dNIsd:d \notin sd

move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd

cset c1 = cset c2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|

c1 (enum_val i) = c2 (enum_val i)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|

d != enum_val i
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
i:ordinal_finType #|sd|

enum_val i \in sd
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd

move rel (cset c1) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd

rel (cset c1 (enum_rank_in dIsd d)) (cset c2 (enum_rank_in dIsd d))
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
forall d2 : 'I_#|sd|, enum_rank_in dIsd d != d2 -> cset c1 d2 = cset c2 d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd

rel (cset c1 (enum_rank_in dIsd d)) (cset c2 (enum_rank_in dIsd d))
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
forall d2 : 'I_#|sd|, enum_rank_in dIsd d != d2 -> cset c1 d2 = cset c2 d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd

forall d2 : 'I_#|sd|, enum_rank_in dIsd d != d2 -> cset c1 d2 = cset c2 d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd

forall d2 : 'I_#|sd|, enum_rank_in dIsd d != d2 -> cset c1 d2 = cset c2 d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2

cset c1 d2 = cset c2 d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2

c1 (enum_val d2) = c2 (enum_val d2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2

d != enum_val d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2

enum_val (enum_rank_in dIsd d) != enum_val d2
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd

on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd

on_top (enum_rank_in dIsd d) (cset c1)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset c2)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset c1 != cset c2
dIsd:d \in sd

on_top (enum_rank_in dIsd d) (cset c2)
by apply: on_top_cset. Qed.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
cs:seq (configuration k n)

path (move rel) c cs -> path (move rel) (cset c) (rm_rep (cset c) [seq cset i | i <- cs])
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c:configuration k n
cs:seq (configuration k n)

path (move rel) c cs -> path (move rel) (cset c) (rm_rep (cset c) [seq cset i | i <- cs])
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> path (move rel) (cset c) (rm_rep (cset c) [seq cset i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs

path (move rel) (cset c) (if cset c == cset c1 then rm_rep (cset c1) [seq cset i | i <- cs] else cset c1 :: rm_rep (cset c1) [seq cset i | i <- cs])
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> path (move rel) (cset c) (rm_rep (cset c) [seq cset i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs
cDc1:cset c != cset c1

move rel (cset c) (cset c1) && path (move rel) (cset c1) (rm_rep (cset c1) [seq cset i | i <- cs])
by rewrite move_cset => //=; first by apply: IH; rewrite ?c2V. Qed.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)

last c1 cs = c2 -> path (move rel) c1 cs -> `d[cset c1, cset c2]_(move rel) <= size cs
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)

last c1 cs = c2 -> path (move rel) c1 cs -> `d[cset c1, cset c2]_(move rel) <= size cs
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

`d[cset c1, cset c2]_(move rel) <= size cs
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

size (rm_rep (cset c1) [seq cset i | i <- cs]) <= size [seq cset i | i <- cs] -> `d[cset c1, cset c2]_(move rel) <= size cs
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

`d[cset c1, cset c2]_(move rel) <= size (rm_rep (cset c1) [seq cset i | i <- cs])
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

last (cset c1) (rm_rep (cset c1) [seq cset i | i <- cs]) = cset c2
by rewrite last_rm_rep last_map cL. Qed.
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))

gpath (move rel) c1 c2 cs -> `d[cset c1, cset c2]_(move rel) <= `d[c1, c2]_(move rel)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))

gpath (move rel) c1 c2 cs -> `d[cset c1, cset c2]_(move rel) <= `d[c1, c2]_(move rel)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs

`d[cset c1, cset c2]_(move rel) <= `d[c1, c2]_(move rel)
n:nat
sd:{set disk n}
k:nat
rel:ssrbool.rel (peg k)
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs

path (move rel) c1 cs
by apply: gpath_path gH. Qed. End ISetd. Arguments gpath [T]. Section CSet. (* Number of disks *) Variable n : nat. (* cut limit *) Variable t : nat. Variable tLn : t <= n. (* Number of pegs *) Variable k : nat. (* relations on peg *) Variable rel : rel (peg k). Hypothesis irH : irreflexive rel. Definition ccut (c : configuration k n) : configuration k t := [ffun i => c (widen_ord tLn i)].
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
d:disk n
dLt:d < t

widen_ord tLn (Ordinal dLt) = d
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
d:disk n
dLt:d < t

widen_ord tLn (Ordinal dLt) = d
by apply: val_inj. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
s:seq (peg k)

codom c \subset s -> codom (ccut c) \subset s
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
s:seq (peg k)

codom c \subset s -> codom (ccut c) \subset s
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
s:seq (peg k)
H:codom c \subset s
i:ordinal_finType k
j:ordinal_finType t

ccut c j \in s
by rewrite ffunE; apply: (subsetP H); apply: codom_f. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k

s2f ([set i | c i == p] :&: isO n t) = s2f [set i | ccut c i == p]
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k

s2f ([set i | c i == p] :&: isO n t) = s2f [set i | ccut c i == p]
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat

(i \in s2f ([set i | c i == p] :&: isO n t)) = (i \in s2f [set i | ccut c i == p])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_n

(c j == p) && (j < t) -> i = j -> exists2 x : 'I_t, x \in [set i | ccut c i == p] & i = x
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_t
ccut c j == p -> i = j -> exists2 x : 'I_n, x \in [set i | c i == p] :&: isO n t & i = x
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_n
cjEp:c j == p
jLt:j < t

exists2 x : 'I_t, x \in [set i | ccut c i == p] & j = x
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_t
ccut c j == p -> i = j -> exists2 x : 'I_n, x \in [set i | c i == p] :&: isO n t & i = x
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_t

ccut c j == p -> i = j -> exists2 x : 'I_n, x \in [set i | c i == p] :&: isO n t & i = x
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
p:disk k
i:nat
j:'I_t
cjEp:c (widen_ord tLn j) == p

widen_ord tLn j \in [set i | c i == p] :&: isO n t
by rewrite !inE /= cjEp /=. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t

on_top d c -> on_top (Ordinal dLr) (ccut c)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t

on_top d c -> on_top (Ordinal dLr) (ccut c)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1

on_top (Ordinal dLr) (ccut c)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_t
H:ccut c (Ordinal dLr) = ccut c d1

d <= d1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_t
H:ccut c (Ordinal dLr) = ccut c d1
dDd1:d != d1

d < d1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_t
H:ccut c (Ordinal dLr) = ccut c d1
dDd1:d != d1

d <= d1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:d < t
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_t
H:ccut c (Ordinal dLr) = ccut c d1
dDd1:d != d1

c d = c (widen_ord tLn d1)
by move: H; rewrite !ffunE ordinalK. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n

move rel c1 c2 -> ccut c1 != ccut c2 -> move rel (ccut c1) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n

move rel c1 c2 -> ccut c1 != ccut c2 -> move rel (ccut c1) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2

move rel (ccut c1) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
dLt:t <= d

move rel (ccut c1) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
move rel (ccut c1) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dLt:t <= d

ccut c1 = ccut c2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
move rel (ccut c1) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dLt:t <= d
i:ordinal_finType t

c1 (widen_ord tLn i) = c2 (widen_ord tLn i)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
move rel (ccut c1) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
dLt:t <= d
i:ordinal_finType t

d != widen_ord tLn i
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
move rel (ccut c1) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t

move rel (ccut c1) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t

rel (ccut c1 (Ordinal tLd)) (ccut c2 (Ordinal tLd))
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
forall d2 : 'I_t, Ordinal tLd != d2 -> ccut c1 d2 = ccut c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t

rel (ccut c1 (Ordinal tLd)) (ccut c2 (Ordinal tLd))
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
forall d2 : 'I_t, Ordinal tLd != d2 -> ccut c1 d2 = ccut c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t

forall d2 : 'I_t, Ordinal tLd != d2 -> ccut c1 d2 = ccut c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t

forall d2 : 'I_t, Ordinal tLd != d2 -> ccut c1 d2 = ccut c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
d2:'I_t
dDd2:d != d2

c1 (widen_ord tLn d2) = c2 (widen_ord tLn d2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t

on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t

on_top (Ordinal tLd) (ccut c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t
on_top (Ordinal tLd) (ccut c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ccut c1 != ccut c2
tLd:d < t

on_top (Ordinal tLd) (ccut c2)
by apply: on_top_cut. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)

path (move rel) c cs -> path (move rel) (ccut c) (rm_rep (ccut c) [seq ccut i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)

path (move rel) c cs -> path (move rel) (ccut c) (rm_rep (ccut c) [seq ccut i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> path (move rel) (ccut c) (rm_rep (ccut c) [seq ccut i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs

path (move rel) (ccut c) (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> path (move rel) (ccut c) (rm_rep (ccut c) [seq ccut i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs
cDc1:ccut c != ccut c1

move rel (ccut c) (ccut c1) && path (move rel) (ccut c1) (rm_rep (ccut c1) [seq ccut i | i <- cs])
by rewrite move_cut => //=; first by apply: IH; rewrite ?c2V. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)

last c1 cs = c2 -> path (move rel) c1 cs -> `d[ccut c1, ccut c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)

last c1 cs = c2 -> path (move rel) c1 cs -> `d[ccut c1, ccut c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

`d[ccut c1, ccut c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

size (rm_rep (ccut c1) [seq ccut i | i <- cs]) <= size [seq ccut i | i <- cs] -> `d[ccut c1, ccut c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

`d[ccut c1, ccut c2]_(move rel) <= size (rm_rep (ccut c1) [seq ccut i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

last (ccut c1) (rm_rep (ccut c1) [seq ccut i | i <- cs]) = ccut c2
by rewrite last_rm_rep last_map cL. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))

gpath (move rel) c1 c2 cs -> `d[ccut c1, ccut c2]_(move rel) <= `d[c1, c2]_(move rel)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))

gpath (move rel) c1 c2 cs -> `d[ccut c1, ccut c2]_(move rel) <= `d[c1, c2]_(move rel)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs

`d[ccut c1, ccut c2]_(move rel) <= `d[c1, c2]_(move rel)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs

path (move rel) c1 cs
by apply: gpath_path gH. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
i:nat

i < n - t -> i + t < n
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
i:nat

i < n - t -> i + t < n
by move=> iLnt; rewrite -(subnK tLn) ltn_add2r. Qed. Definition tuc_ord (i : disk (n - t)) : disk n := Ordinal (tuc_subproof (ltn_ord i)).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
i:nat

i < n -> t <= i -> i - t < n - t
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
i:nat

i < n -> t <= i -> i - t < n - t
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
i:nat
iLn:i < n
tLi:t <= i

t < n
by apply: leq_ltn_trans iLn. Qed. Definition otuc (i : disk n) (tLi : t <= i) : disk (n - t) := Ordinal (otuc_subproof (ltn_ord i) tLi).
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
d:disk n
tLd:t <= d

tuc_ord (otuc tLd) = d
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
d:disk n
tLd:t <= d

tuc_ord (otuc tLd) = d
by apply: val_inj; rewrite /= subnK. Qed. Definition ctuc (c : configuration k n) : configuration k (n - t) := [ffun i => c (tuc_ord i)].
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d

on_top d c -> on_top (otuc dLr) (ctuc c)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d

on_top d c -> on_top (otuc dLr) (ctuc c)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1

on_top (otuc dLr) (ctuc c)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_(n - t)
H:ctuc c (otuc dLr) = ctuc c d1

d - t <= d1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_(n - t)
H:ctuc c (otuc dLr) = ctuc c d1
dDd1:d - t != d1

d - t < d1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_(n - t)
H:ctuc c (otuc dLr) = ctuc c d1
dDd1:d - t != d1

d <= d1 + t
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
d:disk n
dLr:t <= d
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_(n - t)
H:ctuc c (otuc dLr) = ctuc c d1
dDd1:d - t != d1

c d = c (tuc_ord d1)
by move: H; rewrite !ffunE otucK. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n

move rel c1 c2 -> ctuc c1 != ctuc c2 -> move rel (ctuc c1) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n

move rel c1 c2 -> ctuc c1 != ctuc c2 -> move rel (ctuc c1) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2

move rel (ctuc c1) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
tLd:d < t

move rel (ctuc c1) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
move rel (ctuc c1) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
tLd:d < t

ctuc c1 = ctuc c2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
move rel (ctuc c1) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
tLd:d < t
i:ordinal_finType (n - t)

c1 (tuc_ord i) = c2 (tuc_ord i)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
move rel (ctuc c1) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
tLd:d < t
i:ordinal_finType (n - t)

d != tuc_ord i
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
move rel (ctuc c1) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d

move rel (ctuc c1) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d

rel (ctuc c1 (otuc dLt)) (ctuc c2 (otuc dLt))
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
forall d2 : 'I_(n - t), otuc dLt != d2 -> ctuc c1 d2 = ctuc c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d

rel (ctuc c1 (otuc dLt)) (ctuc c2 (otuc dLt))
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
forall d2 : 'I_(n - t), otuc dLt != d2 -> ctuc c1 d2 = ctuc c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d

forall d2 : 'I_(n - t), otuc dLt != d2 -> ctuc c1 d2 = ctuc c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d

forall d2 : 'I_(n - t), otuc dLt != d2 -> ctuc c1 d2 = ctuc c2 d2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
d2:'I_(n - t)
dDd2:d - t != d2

c1 (tuc_ord d2) = c2 (tuc_ord d2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d

on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d

on_top (otuc dLt) (ctuc c1)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d
on_top (otuc dLt) (ctuc c2)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
d:ordinal_finType n
dH1:rel (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:ctuc c1 != ctuc c2
dLt:t <= d

on_top (otuc dLt) (ctuc c2)
by apply: on_top_tuc. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)

path (move rel) c cs -> path (move rel) (ctuc c) (rm_rep (ctuc c) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)

path (move rel) c cs -> path (move rel) (ctuc c) (rm_rep (ctuc c) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> path (move rel) (ctuc c) (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs

path (move rel) (ctuc c) (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> path (move rel) (ctuc c) (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
cMc1:move rel c c1
c1Pcs:path (move rel) c1 cs
cDc1:ctuc c != ctuc c1

move rel (ctuc c) (ctuc c1) && path (move rel) (ctuc c1) (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
by rewrite move_tuc => //=; first by apply: IH; rewrite ?c2V. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)

last c1 cs = c2 -> path (move rel) c1 cs -> `d[ctuc c1, ctuc c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)

last c1 cs = c2 -> path (move rel) c1 cs -> `d[ctuc c1, ctuc c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

`d[ctuc c1, ctuc c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

size (rm_rep (ctuc c1) [seq ctuc i | i <- cs]) <= size [seq ctuc i | i <- cs] -> `d[ctuc c1, ctuc c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

`d[ctuc c1, ctuc c2]_(move rel) <= size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

last (ctuc c1) (rm_rep (ctuc c1) [seq ctuc i | i <- cs]) = ctuc c2
by rewrite last_rm_rep last_map cL. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))

gpath (move rel) c1 c2 cs -> `d[ctuc c1, ctuc c2]_(move rel) <= `d[c1, c2]_(move rel)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))

gpath (move rel) c1 c2 cs -> `d[ctuc c1, ctuc c2]_(move rel) <= `d[c1, c2]_(move rel)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs

`d[ctuc c1, ctuc c2]_(move rel) <= `d[c1, c2]_(move rel)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs

path (move rel) c1 cs
by apply: gpath_path gH. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)

path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c:configuration k n
cs:seq (configuration k n)

path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs

(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs

c d != c1 d
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d

(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t

(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t

ccut c != ccut c1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 = (size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t

ccut c (Ordinal dLt) = ccut c1 (Ordinal dLt) -> False
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 = (size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t

(size cs).+1 = (size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t

ctuc c == ctuc c1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 = (size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
i:ordinal_finType (n - t)

d != tuc_ord i
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 = (size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
i:ordinal_finType (n - t)

val d == val (tuc_ord i) -> False
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t
(size cs).+1 = (size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
dLt:d < t

(size cs).+1 = (size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d

(size cs).+1 = size (if ccut c == ccut c1 then rm_rep (ccut c1) [seq ccut i | i <- cs] else ccut c1 :: rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d

ccut c == ccut c1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
i:ordinal_finType t

d != widen_ord tLn i
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d

(size cs).+1 = size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (if ctuc c == ctuc c1 then rm_rep (ctuc c1) [seq ctuc i | i <- cs] else ctuc c1 :: rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d

ctuc c != ctuc c1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + (size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d

ctuc c (otuc tLd) == ctuc c1 (otuc tLd) -> False
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d
(size cs).+1 = size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + (size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, path (move rel) c cs -> size cs = size (rm_rep (ccut c) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c) [seq ctuc i | i <- cs])
c:configuration k n
d:ordinal_finType n
dH1:rel (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel) c1 cs
cdDc1d:c d != c1 d
tLd:t <= d

(size cs).+1 = size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + (size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])).+1
by rewrite addnS; congr (_.+1); apply: IH. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)

last c1 cs = c2 -> path (move rel) c1 cs -> `d[ccut c1, ccut c2]_(move rel) + `d[ctuc c1, ctuc c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)

last c1 cs = c2 -> path (move rel) c1 cs -> `d[ccut c1, ccut c2]_(move rel) + `d[ctuc c1, ctuc c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

`d[ccut c1, ccut c2]_(move rel) + `d[ctuc c1, ctuc c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

`d[ccut c1, ccut c2]_(move rel) + `d[ctuc c1, ctuc c2]_(move rel) <= size (rm_rep (ccut c1) [seq ccut i | i <- cs]) + size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

`d[ccut c1, ccut c2]_(move rel) <= size (rm_rep (ccut c1) [seq ccut i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ctuc c1, ctuc c2]_(move rel) <= size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

last (ccut c1) (rm_rep (ccut c1) [seq ccut i | i <- cs]) = ccut c2
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs
`d[ctuc c1, ctuc c2]_(move rel) <= size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

`d[ctuc c1, ctuc c2]_(move rel) <= size (rm_rep (ctuc c1) [seq ctuc i | i <- cs])
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:configuration k n
cs:seq (configuration k n)
cL:last c1 cs = c2
cPcs:path (move rel) c1 cs

last (ctuc c1) (rm_rep (ctuc c1) [seq ctuc i | i <- cs]) = ctuc c2
by rewrite last_rm_rep last_map cL. Qed.
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))

gpath (move rel) c1 c2 cs -> `d[ccut c1, ccut c2]_(move rel) + `d[ctuc c1, ctuc c2]_(move rel) <= `d[c1, c2]_(move rel)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))

gpath (move rel) c1 c2 cs -> `d[ccut c1, ccut c2]_(move rel) + `d[ctuc c1, ctuc c2]_(move rel) <= `d[c1, c2]_(move rel)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs

`d[ccut c1, ccut c2]_(move rel) + `d[ctuc c1, ctuc c2]_(move rel) <= `d[c1, c2]_(move rel)
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs

`d[ccut c1, ccut c2]_(move rel) + `d[ctuc c1, ctuc c2]_(move rel) <= size cs
n, t:nat
tLn:t <= n
k:nat
rel:ssrbool.rel (peg k)
irH:irreflexive rel
c1, c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (finfun_finType (ordinal_finType n) (ordinal_finType k))
gH:gpath (move rel) c1 c2 cs

path (move rel) c1 cs
by apply: gpath_path gH. Qed. End CSet. Section ISet. (* Number of disks *) Variable n : nat. (* Subset of disks *) Variable sd : {set disk n}. (* Number of pegs *) Variable k : nat. (* Subset of pegs *) Variable sp : {set peg k}. (* The subset is non empty *) Variable p0 : peg k. Variable p0Isp : p0 \in sp. (* relations on peg *) Variable rel1 : rel (peg k). Variable rel2 : rel (peg #|sp|). Hypothesis rel_compat : forall p1 p2, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2). (* Valid conf : disk in sd are on pegs in sp *) Definition cvalid (c : configuration k n) := [forall i, (i \in sd) ==> (c i \in sp)].
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n

reflect (forall i : ordinal_finType n, i \in sd -> c i \in sp) (cvalid c)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n

reflect (forall i : ordinal_finType n, i \in sd -> c i \in sp) (cvalid c)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
H:forall i : ordinal_finType n, i \in sd -> c i \in sp
d:ordinal_finType n

(d \in sd) ==> (c d \in sp)
by apply/implyP/H. Qed. Definition cset2 (c : configuration k n) : configuration #|sp| #|sd| := [ffun i => enum_rank_in p0Isp (c (enum_val i))].
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd

cvalid c -> on_top d c -> on_top (enum_rank_in dIsd d) (cset2 c)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd

cvalid c -> on_top d c -> on_top (enum_rank_in dIsd d) (cset2 c)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1

on_top (enum_rank_in dIsd d) (cset2 c)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1

enum_rank_in dIsd d <= d1
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1

enum_rank_in dIsd d < d1
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1

enum_val d1 \in sd
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
d < enum_val d1
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1

d < enum_val d1
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1

(d != enum_val d1) && (d <= enum_val d1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
dEd1:d = enum_val d1

~~ true && (d <= enum_val d1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
d <= enum_val d1
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
H:cset2 c (enum_rank_in dIsd d) = cset2 c d1
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1

d <= enum_val d1
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
dO:forall d1 : ordinal_finType n, c d = c d1 -> d <= d1
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:enum_rank_in p0Isp (c d) = enum_rank_in p0Isp (c (enum_val d1))

d <= enum_val d1
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:enum_rank_in p0Isp (c d) = enum_rank_in p0Isp (c (enum_val d1))

c d = c (enum_val d1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:enum_rank_in p0Isp (c d) = enum_rank_in p0Isp (c (enum_val d1))

c d \in sp
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:enum_rank_in p0Isp (c d) = enum_rank_in p0Isp (c (enum_val d1))
c (enum_val d1) \in sp
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
d:ordinal_finType n
dIsd:d \in sd
cV:forall i : ordinal_finType n, i \in sd -> c i \in sp
d1:'I_#|[eta sd]|
dDd1:enum_rank_in dIsd d != d1
dDd1':d != enum_val d1
H:enum_rank_in p0Isp (c d) = enum_rank_in p0Isp (c (enum_val d1))

c (enum_val d1) \in sp
by apply/cV/enum_valP. Qed.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n

all cvalid [:: c1; c2] -> move rel1 c1 c2 -> cset2 c1 != cset2 c2 -> move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n

all cvalid [:: c1; c2] -> move rel1 c1 c2 -> cset2 c1 != cset2 c2 -> move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n

[&& cvalid c1, cvalid c2 & true] -> move rel1 c1 c2 -> cset2 c1 != cset2 c2 -> move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2

move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dNIsd:d \notin sd

move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd

cset2 c1 = cset2 c2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|

enum_rank_in p0Isp (c1 (enum_val i)) = enum_rank_in p0Isp (c2 (enum_val i))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|

enum_val (enum_rank_in p0Isp (c1 (enum_val i))) = enum_val (enum_rank_in p0Isp (c2 (enum_val i)))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|

c1 (enum_val i) = c2 (enum_val i)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
dNIsd:d \notin sd
i:ordinal_finType #|sd|

d != enum_val i
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
i:ordinal_finType #|sd|

enum_val i \in sd
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd

move rel2 (cset2 c1) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd

rel2 (cset2 c1 (enum_rank_in dIsd d)) (cset2 c2 (enum_rank_in dIsd d))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
forall d2 : 'I_#|sd|, enum_rank_in dIsd d != d2 -> cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd

rel2 (cset2 c1 (enum_rank_in dIsd d)) (cset2 c2 (enum_rank_in dIsd d))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
forall d2 : 'I_#|sd|, enum_rank_in dIsd d != d2 -> cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd

rel2 (enum_rank_in p0Isp (c1 d)) (enum_rank_in p0Isp (c2 d))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
forall d2 : 'I_#|sd|, enum_rank_in dIsd d != d2 -> cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd

forall d2 : 'I_#|sd|, enum_rank_in dIsd d != d2 -> cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd

forall d2 : 'I_#|sd|, enum_rank_in dIsd d != d2 -> cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2

cset2 c1 d2 = cset2 c2 d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2

enum_rank_in p0Isp (c1 (enum_val d2)) = enum_rank_in p0Isp (c2 (enum_val d2))
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2

c1 (enum_val d2) = c2 (enum_val d2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2

d != enum_val d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
d2:'I_#|sd|
dDd2:enum_rank_in dIsd d != d2

enum_val (enum_rank_in dIsd d) != enum_val d2
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd

on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd

on_top (enum_rank_in dIsd d) (cset2 c1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd
on_top (enum_rank_in dIsd d) (cset2 c2)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
c1V:cvalid c1
c2V:cvalid c2
d:ordinal_finType n
dH1:rel1 (c1 d) (c2 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c1 d2 = c2 d2
dH3:on_top d c1
dH4:on_top d c2
c1Dc2:cset2 c1 != cset2 c2
dIsd:d \in sd

on_top (enum_rank_in dIsd d) (cset2 c2)
by apply: on_top_cset2. Qed.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
cs:seq (configuration k n)

all cvalid (c :: cs) -> path (move rel1) c cs -> path (move rel2) (cset2 c) (rm_rep (cset2 c) [seq cset2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c:configuration k n
cs:seq (configuration k n)

all cvalid (c :: cs) -> path (move rel1) c cs -> path (move rel2) (cset2 c) (rm_rep (cset2 c) [seq cset2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid c && all cvalid cs -> path (move rel1) c cs -> path (move rel2) (cset2 c) (rm_rep (cset2 c) [seq cset2 i | i <- cs])
c:configuration k n
c1V:cvalid c
c2V:cvalid c1
c3V:all cvalid cs
cMc1:move rel1 c c1
c1Pcs:path (move rel1) c1 cs

path (move rel2) (cset2 c) (if cset2 c == cset2 c1 then rm_rep (cset2 c1) [seq cset2 i | i <- cs] else cset2 c1 :: rm_rep (cset2 c1) [seq cset2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid c && all cvalid cs -> path (move rel1) c cs -> path (move rel2) (cset2 c) (rm_rep (cset2 c) [seq cset2 i | i <- cs])
c:configuration k n
c1V:cvalid c
c2V:cvalid c1
c3V:all cvalid cs
cMc1:move rel1 c c1
c1Pcs:path (move rel1) c1 cs
cDc1:cset2 c != cset2 c1

move rel2 (cset2 c) (cset2 c1) && path (move rel2) (cset2 c1) (rm_rep (cset2 c1) [seq cset2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid c && all cvalid cs -> path (move rel1) c cs -> path (move rel2) (cset2 c) (rm_rep (cset2 c) [seq cset2 i | i <- cs])
c:configuration k n
c1V:cvalid c
c2V:cvalid c1
c3V:all cvalid cs
cMc1:move rel1 c c1
c1Pcs:path (move rel1) c1 cs
cDc1:cset2 c != cset2 c1

[&& cvalid c, cvalid c1 & true]
by rewrite c1V c2V. Qed.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)

all cvalid (c1 :: cs) -> last c1 cs = c2 -> path (move rel1) c1 cs -> `d[cset2 c1, cset2 c2]_(move rel2) <= size cs
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)

all cvalid (c1 :: cs) -> last c1 cs = c2 -> path (move rel1) c1 cs -> `d[cset2 c1, cset2 c2]_(move rel2) <= size cs
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs

`d[cset2 c1, cset2 c2]_(move rel2) <= size cs
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs

size (rm_rep (cset2 c1) [seq cset2 i | i <- cs]) <= size [seq cset2 i | i <- cs] -> `d[cset2 c1, cset2 c2]_(move rel2) <= size cs
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs

`d[cset2 c1, cset2 c2]_(move rel2) <= size (rm_rep (cset2 c1) [seq cset2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1, c2:configuration k n
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs

last (cset2 c1) (rm_rep (cset2 c1) [seq cset2 i | i <- cs]) = cset2 c2
by rewrite last_rm_rep last_map cL. Qed.
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1:configuration k n
c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (configuration k n)

all cvalid (c1 :: cs) -> gpath (move rel1) c1 c2 cs -> `d[cset2 c1, cset2 c2]_(move rel2) <= `d[c1, c2]_(move rel1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1:configuration k n
c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (configuration k n)

all cvalid (c1 :: cs) -> gpath (move rel1) c1 c2 cs -> `d[cset2 c1, cset2 c2]_(move rel2) <= `d[c1, c2]_(move rel1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1:configuration k n
c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
gH:gpath (move rel1) c1 c2 cs

`d[cset2 c1, cset2 c2]_(move rel2) <= `d[c1, c2]_(move rel1)
n:nat
sd:{set disk n}
k:nat
sp:{set peg k}
p0:peg k
p0Isp:p0 \in sp
rel1:rel (peg k)
rel2:rel (peg #|sp|)
rel_compat:forall p1 p2 : ordinal_finType k, p1 \in sp -> p2 \in sp -> rel1 p1 p2 -> rel2 (enum_rank_in p0Isp p1) (enum_rank_in p0Isp p2)
c1:configuration k n
c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (configuration k n)
cV:all cvalid (c1 :: cs)
gH:gpath (move rel1) c1 c2 cs

path (move rel1) c1 cs
by apply: gpath_path gH. Qed. End ISet. Section ISet2. (* Number of disks *) Variable n : nat. (* Subset of disks *) Variable sd : {set disk n}. (* Number of pegs *) Variable k : nat. (* Subsets of pegs *) Variables sp1 sp2 : {set peg k}. (* The subsets are non empty *) Variable p1 p2 : peg k. Variable p1Isp1 : p1 \in sp1. Variable p2Isp2 : p2 \in sp2. (* relations on peg *) Variable rel1 : rel (peg k). Variable rel2 : rel (peg #|sp1|). Variable rel3 : rel (peg #|sp2|). Hypothesis irH : irreflexive rel1. Hypothesis rel2_compat : forall pi pj, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj). Hypothesis rel3_compat : forall pi pj, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj).
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c:configuration k n
cs:seq (configuration k n)

all (cvalid sd sp1) (c :: cs) -> all (cvalid (~: sd) sp2) (c :: cs) -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c:configuration k n
cs:seq (configuration k n)

all (cvalid sd sp1) (c :: cs) -> all (cvalid (~: sd) sp2) (c :: cs) -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs

(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs

c d != c1 d
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d

(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd

(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd

cset2 sd p1Isp1 c != cset2 sd p1Isp1 c1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 = (size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd

cset2 sd p1Isp1 c (enum_rank_in dIsd d) = cset2 sd p1Isp1 c1 (enum_rank_in dIsd d) -> False
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 = (size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
H:c d \in sp1 -> c1 d \in sp1 -> c d = c1 d

False
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 = (size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
dIsd:d \in sd

c1 d \in sp1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 = (size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd

(size cs).+1 = (size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd

cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 = (size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
i:ordinal_finType #|~: sd|

d != enum_val i
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 = (size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
i:ordinal_finType #|~: sd|

enum_val i \notin sd -> d != enum_val i
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd
(size cs).+1 = (size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dIsd:d \in sd

(size cs).+1 = (size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd

(size cs).+1 = size (if cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1 then rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs] else cset2 sd p1Isp1 c1 :: rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd

cset2 sd p1Isp1 c == cset2 sd p1Isp1 c1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
i:ordinal_finType #|sd|

d != enum_val i
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
i:ordinal_finType #|sd|

enum_val i \in sd
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd

(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd

(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (if cset2 (~: sd) p2Isp2 c == cset2 (~: sd) p2Isp2 c1 then rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs] else cset2 (~: sd) p2Isp2 c1 :: rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd

cset2 (~: sd) p2Isp2 c != cset2 (~: sd) p2Isp2 c1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + (size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd

cset2 (~: sd) p2Isp2 c (enum_rank_in dd d) = cset2 (~: sd) p2Isp2 c1 (enum_rank_in dd d) -> False
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + (size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
H:c d \in sp2 -> c1 d \in sp2 -> c d = c1 d

False
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + (size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
dNIsd:d \notin sd
dd:d \in ~: sd

c d \in sp2
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
dNIsd:d \notin sd
dd:d \in ~: sd
c1 d \in sp2
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + (size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
dNIsd:d \notin sd
dd:d \in ~: sd

c1 d \in sp2
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd
(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + (size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
cs:seq (configuration k n)
IH:forall c : configuration k n, cvalid sd sp1 c && all (cvalid sd sp1) cs -> cvalid (~: sd) sp2 c && all (cvalid (~: sd) sp2) cs -> path (move rel1) c cs -> size cs = size (rm_rep (cset2 sd p1Isp1 c) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
c:configuration k n
c1V1:cvalid sd sp1 c
c2V1:cvalid sd sp1 c1
c3V1:all (cvalid sd sp1) cs
c1V2:cvalid (~: sd) sp2 c
c2V2:cvalid (~: sd) sp2 c1
c3V2:all (cvalid (~: sd) sp2) cs
d:ordinal_finType n
dH1:rel1 (c d) (c1 d)
dH2:forall d2 : ordinal_finType n, d != d2 -> c d2 = c1 d2
dH3:on_top d c
dH4:on_top d c1
c1Pcs:path (move rel1) c1 cs
cdDc1d:c d != c1 d
dNIsd:d \notin sd
dd:d \in ~: sd

(size cs).+1 = size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + (size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])).+1
by rewrite addnS; congr (_.+1); apply: IH; rewrite ?c2V1 ?c2V2. Qed.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)

all (cvalid sd sp1) (c1 :: cs) -> all (cvalid (~: sd) sp2) (c1 :: cs) -> last c1 cs = c2 -> path (move rel1) c1 cs -> `d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) + `d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= size cs
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)

all (cvalid sd sp1) (c1 :: cs) -> all (cvalid (~: sd) sp2) (c1 :: cs) -> last c1 cs = c2 -> path (move rel1) c1 cs -> `d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) + `d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= size cs
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs

`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) + `d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= size cs
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs

`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) + `d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) + size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs

`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) <= size (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs

last (cset2 sd p1Isp1 c1) (rm_rep (cset2 sd p1Isp1 c1) [seq cset2 sd p1Isp1 i | i <- cs]) = cset2 sd p1Isp1 c2
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs
`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs

`d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= size (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs])
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1, c2:configuration k n
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
cL:last c1 cs = c2
cPcs:path (move rel1) c1 cs

last (cset2 (~: sd) p2Isp2 c1) (rm_rep (cset2 (~: sd) p2Isp2 c1) [seq cset2 (~: sd) p2Isp2 i | i <- cs]) = cset2 (~: sd) p2Isp2 c2
by rewrite last_rm_rep last_map cL. Qed.
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (configuration k n)

all (cvalid sd sp1) (c1 :: cs) -> all (cvalid (~: sd) sp2) (c1 :: cs) -> gpath (move rel1) c1 c2 cs -> `d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) + `d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= `d[c1, c2]_(move rel1)
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (configuration k n)

all (cvalid sd sp1) (c1 :: cs) -> all (cvalid (~: sd) sp2) (c1 :: cs) -> gpath (move rel1) c1 c2 cs -> `d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) + `d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= `d[c1, c2]_(move rel1)
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
gH:gpath (move rel1) c1 c2 cs

`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) + `d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= `d[c1, c2]_(move rel1)
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
gH:gpath (move rel1) c1 c2 cs

`d[cset2 sd p1Isp1 c1, cset2 sd p1Isp1 c2]_(move rel2) + `d[cset2 (~: sd) p2Isp2 c1, cset2 (~: sd) p2Isp2 c2]_ (move rel3) <= size cs
n:nat
sd:{set disk n}
k:nat
sp1, sp2:{set peg k}
p1, p2:peg k
p1Isp1:p1 \in sp1
p2Isp2:p2 \in sp2
rel1:rel (peg k)
rel2:rel (peg #|sp1|)
rel3:rel (peg #|sp2|)
irH:irreflexive rel1
rel2_compat:forall pi pj : ordinal_finType k, pi \in sp1 -> pj \in sp1 -> rel1 pi pj -> rel2 (enum_rank_in p1Isp1 pi) (enum_rank_in p1Isp1 pj)
rel3_compat:forall pi pj : ordinal_finType k, pi \in sp2 -> pj \in sp2 -> rel1 pi pj -> rel3 (enum_rank_in p2Isp2 pi) (enum_rank_in p2Isp2 pj)
c1:configuration k n
c2:finfun_finType (ordinal_finType n) (ordinal_finType k)
cs:seq (configuration k n)
cV1:all (cvalid sd sp1) (c1 :: cs)
cV2:all (cvalid (~: sd) sp2) (c1 :: cs)
gH:gpath (move rel1) c1 c2 cs

path (move rel1) c1 cs
by apply: gpath_path gH. Qed. End ISet2.